home *** CD-ROM | disk | FTP | other *** search
/ Amiga Format CD 23 / Amiga Format AFCD23 (Feb 1998, Issue 107).iso / mui / mui_developer / c / examples / psi.c < prev    next >
C/C++ Source or Header  |  1997-03-10  |  89KB  |  2,870 lines
  1. /*
  2.  
  3. Public Screen Inspector Source Code
  4. -----------------------------------
  5.  
  6. This source acts as an example of good object-oriented MUI programming.
  7. Lots of important techniques are demonstrated:
  8.  
  9. - Sub Classes:
  10.   The complete application consists of several independant sub classes
  11.   which are connected to create a screen manager. This is one of the
  12.   *major* issues of good MUI programming. Don't put everything into
  13.   your main loop, use classes instead!
  14.  
  15. - Dynamic Object Creation:
  16.   Creating all the objects of an application at startup time is often
  17.   unnecessary and wastes time and memory. Instead, create the objects
  18.   only when you need them, add them dynamically to your application
  19.   and dispose them when you're done. Here, edit windows are created
  20.   on demand and color wheels only show up when needed.
  21.  
  22. - Multi Threading:
  23.   Sub classes and dynamic object generation make it easy to create
  24.   multi-threaded programs. With the screen manager, the user will be
  25.   able to edit as many screens as he wants at once.
  26.  
  27. - Drag&Drop:
  28.   Drag&Drop possibilities are important for a good GUI and are implemented
  29.   with a few lines of code. The color panel in this program is a good
  30.   example.
  31.  
  32.  
  33. Let's describe the process of creating a nice MUI application with this
  34. screen manager example. Maybe the following explanation sounds a bit
  35. crazy at first, but you should read it completely anyway to get an idea
  36. of how object-oriented programming is supposed to work.
  37.  
  38. At startup time, the screen manager opens a window which offers
  39. possibilities to edit a public screen list and to Save/Use/Cancel the
  40. work. This window is the main window of the program and since we want to
  41. be nice object-oriented, we will of course create a MainWindow class as
  42. subclass of window class for our window.
  43.  
  44. The MainWindow class itself features a screen list with edit buttons
  45. and the well known Save/Use/Cancel buttons. Of course, the screen list
  46. with edit buttons is not included directly but instead encapsulated in
  47. another sub class called the ScreenPanel class.
  48.  
  49. ScreenPanel class is a sub class of group class and includes a listview
  50. with all defined public screens (which is in fact created by a sub class
  51. of list class, the ScreenList class) and some New/Delete/Edit buttons
  52. below the listview. It implements methods to open and close edit windows
  53. for each entry of the listview and calls these methodes itself whenever
  54. the user presses an appropriate button. Guess what... when a list entry
  55. needs to be edited, ScreenPanel class simply creates a new instance of
  56. the EditWindow class.
  57.  
  58. As a subclass of window class, EditWindow opens a window which lets the
  59. user edit the data of a public screen. Of course it doesn't handle this
  60. editing itself, an EditWindow itself only consists of an EditPanel sub
  61. class and two obvious OK and Cancel buttons.
  62.  
  63. EditPanel sub class is a subclass of group class and offers three
  64. different pages to change the public screen data. This class is
  65. somewhat *major* since the main action of the program, the editing
  66. of public screen data, takes place here. Of course, the EditPanel
  67. class doesn't do all the editing work itself. Instead, it relies
  68. on further sub classes, e.g. a DispIDlist which creates a list
  69. of of available DisplayIDs or a DispIDinfo list which shows
  70. information on a specific display ID.
  71.  
  72. Ok... that's basically the description of the object oriented screen
  73. manager. Let's repeat the sub class structure of this application
  74. again in a little diagram. Every class consists of the sub classes
  75. included in the first level of braces below its name.
  76.  
  77. ApplicationClass
  78. {
  79.     MainWindow
  80.     {
  81.         ScreenPanel
  82.         {
  83.             ScreenList
  84.             {
  85.                 EditWindow
  86.                 {
  87.                     EditPanel
  88.                     {
  89.                         DispIDlist
  90.                         DispIDinfo
  91.                     }
  92.                     OK/Cancel
  93.                 }
  94.             }
  95.             New/Delete/Edit
  96.         }
  97.         Save/Use/Cancel
  98.     }
  99. }
  100.  
  101. Maybe you think that this sub classing is a bit overpowered or
  102. unnecessary or ridicolous, you could do everything just fine with one
  103. big Main-Loop which contains everything you need. Let me tell you one
  104. thing: You can never have enough sub classes in an application! :-)
  105.  
  106. The smaller your classes are, the lesser complex your complete project
  107. will be. When working on "higher levels" of your program, e.g. when
  108. adding more functionality to the ScreenPanel or to the MainWindow, you
  109. don't have to think about side effects and stuff on the lower levels. As
  110. long as each class has it's well defined set of attributes and methods,
  111. everything will continue to work like a charm.
  112.  
  113. On the other side, when fixing bugs or e.g. implementing new features
  114. like Drag&Drop for a "low-level" class like the DispIDlist, you have to
  115. deal with just a few lines of code, not with a big bunch of lines from a
  116. complete application.
  117.  
  118. To come to the point... when building a new application, you should
  119. first think of what different parts your program consists of and how you
  120. could divide your work in big sub classes. Then, take the big classes
  121. and split each of them into smaller classes, take the smaller classes
  122. and split them even more. Split as long as you are unable to split
  123. anymore! If you splitted nicely, you will have lots of classes which all
  124. perform some well-defined actions and are all very easy to implement.
  125.  
  126. A few more tips...
  127.  
  128. - Don't use ReturnIDs!
  129.     I feel very sorry that I implemented this rubbish in MUI. ReturnIDs are
  130.     completely against object-orientation and break the nice class structure
  131.     that every MUI application should have. The ideal input loop of every
  132.     application looks like this:
  133.  
  134.     {
  135.         ULONG sigs = 0;
  136.  
  137.         while (DoMethod(app,MUIM_Application_NewInput,&sigs) != MUIV_Application_ReturnID_Quit)
  138.         {
  139.             if (sigs)
  140.             {
  141.                 sigs = Wait(sigs | SIGBREAKF_CTRL_C);
  142.                 if (sigs & SIGBREAKF_CTRL_C) break;
  143.             }
  144.         }
  145.     }
  146.  
  147.     That's it. If you're input loop looks different, i.e. if you use the
  148.     return value of the input method for more than the QUIT check, you're
  149.     program is not as object-oriented as it could be. Feel ashamed! :-)
  150. */
  151.  
  152. #include "psi.h"
  153.  
  154.  
  155. #define BETWEEN(a,x,b) ((x)>=(a) && (x)<=(b))
  156.  
  157.  
  158. /* $setver$ */
  159. static const char VersionString[] = "$VER: PSI 19.8 (12.02.97)";
  160. #define VERSION  19
  161. #define REVISION 8
  162.  
  163.  
  164. /****************************************************************************/
  165. /* Private Functions of muiscreen.library                                   */
  166. /****************************************************************************/
  167.  
  168. /*
  169. ** NOTE: Never use one of these in your own programs. I guarantee to change
  170. **       the offsets with every new MUI release.
  171. */
  172.  
  173. struct MUI_PubScreenDesc *MUIS_AllocPubScreenDesc(struct MUI_PubScreenDesc *src);
  174. VOID                      MUIS_FreePubScreenDesc(struct MUI_PubScreenDesc *psd);
  175. char *                    MUIS_OpenPubScreen(struct MUI_PubScreenDesc *desc);
  176. BOOL                      MUIS_ClosePubScreen(char *name);
  177. APTR                      MUIS_OpenPubFile(char *name,ULONG mode);
  178. VOID                      MUIS_ClosePubFile(APTR pf);
  179. struct MUI_PubScreenDesc *MUIS_ReadPubFile(APTR pf);
  180. BOOL                      MUIS_WritePubFile(APTR pf,struct MUI_PubScreenDesc *desc);
  181. VOID                      MUIS_AddInfoClient(struct MUIS_InfoClient *sic);
  182. VOID                      MUIS_RemInfoClient(struct MUIS_InfoClient *sic);
  183.  
  184. #pragma libcall MUIScreenBase MUIS_AllocPubScreenDesc 1e 801
  185. #pragma libcall MUIScreenBase MUIS_FreePubScreenDesc 24 801
  186. #pragma libcall MUIScreenBase MUIS_OpenPubFile 2a 0802
  187. #pragma libcall MUIScreenBase MUIS_ClosePubFile 30 801
  188. #pragma libcall MUIScreenBase MUIS_ReadPubFile 36 801
  189. #pragma libcall MUIScreenBase MUIS_WritePubFile 3c 9802
  190. #pragma libcall MUIScreenBase MUIS_OpenPubScreen 42 801
  191. #pragma libcall MUIScreenBase MUIS_ClosePubScreen 48 801
  192. #pragma libcall MUIScreenBase MUIS_AddInfoClient 4e 801
  193. #pragma libcall MUIScreenBase MUIS_RemInfoClient 54 801
  194.  
  195.  
  196.  
  197. /****************************************************************************/
  198. /* Global Vars                                                              */
  199. /****************************************************************************/
  200.  
  201. LONG __stack = 10000;
  202.  
  203. struct Library *MUIScreenBase;
  204. struct Library *MUIMasterBase;
  205. struct Library *GfxBase      ;
  206. struct Library *IntuitionBase;
  207. struct Library *LocaleBase   ;
  208. struct Library *AslBase      ;
  209. struct Library *UtilityBase  ;
  210.  
  211. extern struct Library *DOSBase;
  212.  
  213. struct Catalog *Catalog;
  214.  
  215. struct MUI_CustomClass *CL_EditWindow  ;
  216. struct MUI_CustomClass *CL_EditPanel   ;
  217. struct MUI_CustomClass *CL_SysPenField ;
  218. struct MUI_CustomClass *CL_DispIDlist  ;
  219. struct MUI_CustomClass *CL_DispIDinfo  ;
  220. struct MUI_CustomClass *CL_ScreenList  ;
  221. struct MUI_CustomClass *CL_ScreenPanel ;
  222. struct MUI_CustomClass *CL_MainWindow  ;
  223.  
  224. #define TG CHECKIT|MENUTOGGLE
  225.  
  226. enum { MEN_OPEN=1,MEN_APPEND,MEN_SAVEAS,MEN_ABOUT,MEN_QUIT,MEN_LASTSAVED,MEN_RESTORE,MEN_MUI };
  227. struct NewMenu MainMenu[] =
  228. {
  229.     { NM_TITLE, (STRPTR)MSG_MENU_PROJECT          , 0 ,0,0,(APTR)0             },
  230.     { NM_ITEM , (STRPTR)MSG_MENU_PROJECT_OPEN     ,"O",0,0,(APTR)MEN_OPEN      },
  231.     { NM_ITEM , (STRPTR)MSG_MENU_PROJECT_APPEND   ,"P",0,0,(APTR)MEN_APPEND    },
  232.     { NM_ITEM , (STRPTR)MSG_MENU_PROJECT_SAVEAS   ,"A",0,0,(APTR)MEN_SAVEAS    },
  233.     { NM_ITEM , (STRPTR)NM_BARLABEL               , 0 ,0,0,(APTR)0             },
  234.     { NM_ITEM , (STRPTR)MSG_MENU_PROJECT_ABOUT    ,"?",0,0,(APTR)MEN_ABOUT     },
  235.     { NM_ITEM , (STRPTR)NM_BARLABEL               , 0 ,0,0,(APTR)0             },
  236.     { NM_ITEM , (STRPTR)MSG_MENU_PROJECT_QUIT     ,"Q",0,0,(APTR)MEN_QUIT      },
  237.  
  238.     { NM_TITLE, (STRPTR)MSG_MENU_EDIT             , 0 ,0,0,(APTR)0             },
  239.     { NM_ITEM , (STRPTR)MSG_MENU_EDIT_LASTSAVED   ,"L",0,0,(APTR)MEN_LASTSAVED },
  240.     { NM_ITEM , (STRPTR)MSG_MENU_EDIT_RESTORE     ,"R",0,0,(APTR)MEN_RESTORE   },
  241.  
  242.     { NM_TITLE, (STRPTR)MSG_MENU_SETTINGS         , 0 ,0,0,(APTR)0             },
  243.     { NM_ITEM , (STRPTR)MSG_MENU_SETTINGS_MUI     , 0 ,0,0,(APTR)MEN_MUI       },
  244.  
  245.     { NM_END,NULL,0,0,0,(APTR)0 },
  246. };
  247.  
  248. struct NewMenu PaletteMenu[] =
  249. {
  250.     { NM_TITLE, (STRPTR)MSG_PALPRES_TITLE, 0 , 0,0,(APTR)0   },
  251.     { NM_ITEM , (STRPTR)MSG_PALPRES_CLONEWB  , 0,0,0,(APTR)10},
  252.     { NM_ITEM , (STRPTR)NM_BARLABEL          , 0,0,0,(APTR)0 },
  253.     { NM_ITEM , (STRPTR)MSG_PALPRES_MAGICWB  , 0,0,0,(APTR)9 },
  254.     { NM_ITEM , (STRPTR)NM_BARLABEL          , 0,0,0,(APTR)0 },
  255.     { NM_ITEM , (STRPTR)MSG_PALPRES_STANDARD , 0,0,0,(APTR)0 },
  256.     { NM_ITEM , (STRPTR)MSG_PALPRES_TINT     , 0,0,0,(APTR)1 },
  257.     { NM_ITEM , (STRPTR)MSG_PALPRES_PHARAO   , 0,0,0,(APTR)2 },
  258.     { NM_ITEM , (STRPTR)MSG_PALPRES_SUNSET   , 0,0,0,(APTR)3 },
  259.     { NM_ITEM , (STRPTR)MSG_PALPRES_OCEAN    , 0,0,0,(APTR)4 },
  260.     { NM_ITEM , (STRPTR)MSG_PALPRES_STEEL    , 0,0,0,(APTR)5 },
  261.     { NM_ITEM , (STRPTR)MSG_PALPRES_CHOCOLATE, 0,0,0,(APTR)6 },
  262.     { NM_ITEM , (STRPTR)MSG_PALPRES_PEWTER   , 0,0,0,(APTR)7 },
  263.     { NM_ITEM , (STRPTR)MSG_PALPRES_WINE     , 0,0,0,(APTR)8 },
  264.  
  265.     { NM_END,NULL,0,0,0,(APTR)0 },
  266. };
  267.  
  268. char *CYA_EditPages[] =
  269. {
  270.     (char *)MSG_EDITPAGE_ATTRIBUTES,
  271.     (char *)MSG_EDITPAGE_DISPLAY,
  272.     (char *)MSG_EDITPAGE_COLORS,
  273.     NULL
  274. };
  275.  
  276. char *CYA_Overscan[] =
  277. {
  278.     (char *)MSG_OVERSCAN_TEXT,
  279.     (char *)MSG_OVERSCAN_GRAPHICS,
  280.     (char *)MSG_OVERSCAN_EXTREME,
  281.     (char *)MSG_OVERSCAN_MAXIMUM,
  282.     NULL
  283. };
  284.  
  285.  
  286. /****************************************************************************/
  287. /* Locale Stuff                                                             */
  288. /****************************************************************************/
  289.  
  290. char *GetStr(int num)
  291. {
  292.     struct CatCompArrayType *cca = (struct CatCompArrayType *)CatCompArray;
  293.     while (cca->cca_ID != num) cca++;
  294.     if (LocaleBase) return(GetCatalogStr(Catalog,num,cca->cca_Str));
  295.     return((char *)cca->cca_Str);
  296. }
  297.  
  298. VOID LocalizeStringArray(char **array)
  299. {
  300.     char **x;
  301.     for (x=array;*x;x++)
  302.         *x = GetStr((int)*x);
  303. }
  304.  
  305. VOID LocalizeNewMenu(struct NewMenu *nm)
  306. {
  307.     for (;nm->nm_Type!=NM_END;nm++)
  308.         if (nm->nm_Label != NM_BARLABEL)
  309.             nm->nm_Label = GetStr((int)nm->nm_Label);
  310. }
  311.  
  312. VOID InitLocale(VOID)
  313. {
  314.     if (LocaleBase = OpenLibrary("locale.library",38))
  315.         Catalog = OpenCatalog(NULL,"psi.catalog",OC_Version,VERSION,TAG_DONE);
  316.  
  317.     LocalizeNewMenu(MainMenu);
  318.     LocalizeNewMenu(PaletteMenu);
  319.     /*LocalizeNewMenu(EditMenu);*/
  320.     LocalizeStringArray(CYA_Overscan);
  321.     LocalizeStringArray(CYA_EditPages);
  322. }
  323.  
  324. VOID ExitLocale(VOID)
  325. {
  326.     if (Catalog) { CloseCatalog(Catalog); Catalog=NULL; }
  327.     if (LocaleBase) CloseLibrary(LocaleBase); { LocaleBase=NULL; }
  328. }
  329.  
  330.  
  331.  
  332. /****************************************************************************/
  333. /* Misc Help Functions                                                      */
  334. /****************************************************************************/
  335.  
  336. LONG xget(Object *obj,ULONG attribute)
  337. {
  338.     LONG x;
  339.     get(obj,attribute,&x);
  340.     return(x);
  341. }
  342.  
  343. char *getstr(Object *obj)
  344. {
  345.     return((char *)xget(obj,MUIA_String_Contents));
  346. }
  347.  
  348. BOOL getbool(Object *obj)
  349. {
  350.     return((BOOL)xget(obj,MUIA_Selected));
  351. }
  352.  
  353. VOID setstr(APTR str,LONG num)
  354. {
  355.     DoMethod(str,MUIM_SetAsString,MUIA_String_Contents,"%ld",num);
  356. }
  357.  
  358. VOID settxt(APTR str,LONG num)
  359. {
  360.     DoMethod(str,MUIM_SetAsString,MUIA_Text_Contents,"%ld",num);
  361. }
  362.  
  363. ULONG __stdargs DoSuperNew(struct IClass *cl,Object *obj,ULONG tag1,...)
  364. {
  365.     return(DoSuperMethod(cl,obj,OM_NEW,&tag1,NULL));
  366. }
  367.  
  368. Object *MakeCheck(int num)
  369. {
  370.     Object *obj = MUI_MakeObject(MUIO_Checkmark,GetStr(num));
  371.     if (obj) set(obj,MUIA_CycleChain,1);
  372.     return(obj);
  373. }
  374.  
  375. Object *MakeButton(int num)
  376. {
  377.     Object *obj = MUI_MakeObject(MUIO_Button,GetStr(num));
  378.     if (obj) set(obj,MUIA_CycleChain,1);
  379.     return(obj);
  380. }
  381.  
  382. /*
  383. Object *MakeBackground(int num)
  384. {
  385.     Object *obj;
  386.  
  387.     obj = MUI_NewObject(MUIC_Popimage,
  388.         MUIA_Imageadjust_Type, MUIV_Imageadjust_Type_Background,
  389.         MUIA_Window_Title, "Adjust Screen Background",
  390.         MUIA_CycleChain, 1,
  391.         TAG_DONE);
  392.  
  393.     return(obj);
  394. }
  395. */
  396.  
  397. Object *MakeString(int maxlen,int num)
  398. {
  399.     Object *obj = MUI_MakeObject(MUIO_String,GetStr(num),maxlen);
  400.  
  401.     if (obj)
  402.     {
  403.         SetAttrs(obj,
  404.             MUIA_CycleChain,1,
  405.             MUIA_String_AdvanceOnCR,TRUE,
  406.             TAG_DONE);
  407.     }
  408.  
  409.     return(obj);
  410. }
  411.  
  412. Object *MakeCycle(char **array,int num)
  413. {
  414.     Object *obj = MUI_MakeObject(MUIO_Cycle ,GetStr(num),array);
  415.     if (obj) set(obj,MUIA_CycleChain,1);
  416.     return(obj);
  417. }
  418.  
  419. Object *MakeSlider(int min,int max,int num)
  420. {
  421.     Object *obj = MUI_MakeObject(MUIO_Slider,GetStr(num),min,max);
  422.     if (obj) set(obj,MUIA_CycleChain,1);
  423.     return(obj);
  424. }
  425.  
  426.  
  427. static Object *MakeCLabel(int num) { return(MUI_MakeObject(MUIO_Label,GetStr(num),MUIO_Label_Centered)); }
  428.  
  429. Object *MakeLabel    (int num)  { return(MUI_MakeObject(MUIO_Label    ,GetStr(num),0)); }
  430. Object *MakeLabel1   (int num)  { return(MUI_MakeObject(MUIO_Label    ,GetStr(num),MUIO_Label_SingleFrame)); }
  431. Object *MakeLabel2   (int num)  { return(MUI_MakeObject(MUIO_Label    ,GetStr(num),MUIO_Label_DoubleFrame)); }
  432. Object *MakeLLabel   (int num)  { return(MUI_MakeObject(MUIO_Label    ,GetStr(num),MUIO_Label_LeftAligned)); }
  433. Object *MakeLLabel1  (int num)  { return(MUI_MakeObject(MUIO_Label    ,GetStr(num),MUIO_Label_LeftAligned|MUIO_Label_SingleFrame)); }
  434. Object *MakeFreeLabel(int num)  { return(MUI_MakeObject(MUIO_Label    ,GetStr(num),MUIO_Label_FreeVert)); }
  435. Object *MakeFreeLLabel(int num) { return(MUI_MakeObject(MUIO_Label    ,GetStr(num),MUIO_Label_FreeVert|MUIO_Label_LeftAligned)); }
  436.  
  437. BOOL TestPubScreen(char *name)
  438. {
  439.     struct List *pslist;
  440.     struct PubScreenNode *psn,*succ;
  441.     BOOL res = FALSE;
  442.     pslist = LockPubScreenList();
  443.     ForEntries(pslist,psn,succ)
  444.     {
  445.         if (!stricmp(psn->psn_Node.ln_Name,name))
  446.         {
  447.             res = TRUE;
  448.             break;
  449.         }
  450.     }
  451.     UnlockPubScreenList();
  452.     return(res);
  453. }
  454.  
  455.  
  456. /****************************************************************************/
  457. /* DisplayIDinfo class                                                      */
  458. /****************************************************************************/
  459.  
  460. struct DispIDinfo_Data
  461. {
  462.     Object *TX_Visible[2];
  463.     Object *TX_Minimum[2];
  464.     Object *TX_Maximum[2];
  465.     Object *TX_BitsPerGun;
  466.     Object *TX_NumColors;
  467.     Object *TX_ScanRate;
  468.     Object *TX_ScanLine;
  469. };
  470.  
  471. Object *MakeMoni(LONG w,LONG h,LONG d,const UBYTE *body,const ULONG *colors)
  472. {
  473.     Object *obj = BodychunkObject,
  474.         MUIA_FixWidth             , w,
  475.         MUIA_FixHeight            , h,
  476.         MUIA_Bitmap_Width         , w,
  477.         MUIA_Bitmap_Height        , h,
  478.         MUIA_Bodychunk_Depth      , d,
  479.         MUIA_Bodychunk_Body       , (UBYTE *)body,
  480.         MUIA_Bodychunk_Compression, PSI_COLORS_COMPRESSION,
  481.         MUIA_Bodychunk_Masking    , PSI_COLORS_MASKING,
  482.         MUIA_Bitmap_SourceColors  , (ULONG *)colors,
  483.         MUIA_Bitmap_Transparent   , 0,
  484.         End;
  485.     return(obj);
  486. }
  487.  
  488. Object *MakeSize(void)
  489. {
  490.     Object *obj = TextObject,
  491.         MUIA_Text_Contents, "0",
  492.         MUIA_Text_PreParse, "\33r",
  493.         MUIA_FixWidthTxt, "00000",
  494.         End;
  495.     return(obj);
  496. }
  497.  
  498. ULONG DispIDinfo_New(struct IClass *cl,Object *obj,struct opSet *msg)
  499. {
  500.     Object *TX_Visible[2];
  501.     Object *TX_Minimum[2];
  502.     Object *TX_Maximum[2];
  503.     Object *TX_BitsPerGun;
  504.     Object *TX_NumColors;
  505.     Object *TX_ScanRate;
  506.     Object *TX_ScanLine;
  507.     Object *g1,*g2,*g3;
  508.  
  509.     obj = (Object *)DoSuperNew(cl,obj,
  510.         MUIA_Group_Columns, 2,
  511.         Child, g1 = MakeMoni(PSI_SIZES_WIDTH,PSI_SIZES_HEIGHT,PSI_SIZES_DEPTH,psi_sizes_body,psi_sizes_colors),
  512.         Child, ColGroup(4), MUIA_Group_VertSpacing, 0, MUIA_Group_HorizSpacing, 4,
  513.             Child, MakeLabel(MSG_LABEL_VISIBLE), Child, TX_Visible[0]=MakeSize(), Child, Label("x"), Child, TX_Visible[1]=MakeSize(),
  514.             Child, MakeLabel(MSG_LABEL_MINIMUM), Child, TX_Minimum[0]=MakeSize(), Child, Label("x"), Child, TX_Minimum[1]=MakeSize(),
  515.             Child, MakeLabel(MSG_LABEL_MAXIMUM), Child, TX_Maximum[0]=MakeSize(), Child, Label("x"), Child, TX_Maximum[1]=MakeSize(),
  516.             End,
  517.         Child, g2 = MakeMoni(PSI_COLORS_WIDTH,PSI_COLORS_HEIGHT,PSI_COLORS_DEPTH,psi_colors_body,psi_sizes_colors),
  518.         Child, ColGroup(2), MUIA_Group_VertSpacing, 0, MUIA_Group_HorizSpacing, 4,
  519.             Child, MakeLabel(MSG_LABEL_BITSPERGUN), Child, TX_BitsPerGun = TextObject, End,
  520.             Child, MakeLabel(MSG_LABEL_MAXIMUM   ), Child, TX_NumColors  = TextObject, End,
  521.             End,
  522.         Child, g3 = MakeMoni(PSI_FREQS_WIDTH,PSI_FREQS_HEIGHT,PSI_FREQS_DEPTH,psi_freqs_body,psi_sizes_colors),
  523.         Child, ColGroup(2), MUIA_Group_VertSpacing, 0, MUIA_Group_HorizSpacing, 4,
  524.             Child, MakeLabel(MSG_LABEL_SCANRATE), Child, TX_ScanRate = TextObject, End,
  525.             Child, MakeLabel(MSG_LABEL_SCANLINE), Child, TX_ScanLine = TextObject, End,
  526.             End,
  527.         TAG_MORE,msg->ops_AttrList);
  528.  
  529.     if (obj)
  530.     {
  531.         struct DispIDinfo_Data *data = INST_DATA(cl,obj);
  532.  
  533. /*
  534.         set(g1,MUIA_VertDisappear,3);
  535.         set(g2,MUIA_VertDisappear,2);
  536.         set(g3,MUIA_VertDisappear,1);
  537. */
  538.  
  539.         data->TX_Visible[0] = TX_Visible[0];
  540.         data->TX_Visible[1] = TX_Visible[1];
  541.         data->TX_Minimum[0] = TX_Minimum[0];
  542.         data->TX_Minimum[1] = TX_Minimum[1];
  543.         data->TX_Maximum[0] = TX_Maximum[0];
  544.         data->TX_Maximum[1] = TX_Maximum[1];
  545.         data->TX_BitsPerGun = TX_BitsPerGun;
  546.         data->TX_NumColors  = TX_NumColors;
  547.         data->TX_ScanRate   = TX_ScanRate;
  548.         data->TX_ScanLine   = TX_ScanLine;
  549.  
  550.         return((ULONG)obj);
  551.     }
  552.  
  553.     return(0);
  554. }
  555.  
  556. ULONG DispIDinfo_Set(struct IClass *cl,Object *obj,struct opSet *msg)
  557. {
  558.     #define offset(a,b) (((ULONG)b)-(((ULONG)a)))
  559.     struct DispIDinfo_Data *data = INST_DATA(cl,obj);
  560.     struct TagItem *tag;
  561.  
  562.     if (tag = FindTagItem(MUIA_DispIDinfo_ID,msg->ops_AttrList))
  563.     {
  564.         struct DisplayInfo   dis;
  565.         struct DimensionInfo dim;
  566.         struct MonitorInfo   mon;
  567.         int dislen;
  568.         int dimlen;
  569.         int monlen;
  570.  
  571.         set(data->TX_Visible[0],MUIA_String_Contents,"");
  572.         set(data->TX_Visible[1],MUIA_String_Contents,"");
  573.         set(data->TX_Minimum[0],MUIA_String_Contents,"");
  574.         set(data->TX_Minimum[1],MUIA_String_Contents,"");
  575.         set(data->TX_Maximum[0],MUIA_String_Contents,"");
  576.         set(data->TX_Maximum[1],MUIA_String_Contents,"");
  577.         set(data->TX_BitsPerGun,MUIA_String_Contents,"");
  578.         set(data->TX_NumColors ,MUIA_String_Contents,"");
  579.         set(data->TX_ScanRate  ,MUIA_String_Contents,"");
  580.         set(data->TX_ScanLine  ,MUIA_String_Contents,"");
  581.  
  582.         dislen = GetDisplayInfoData(0,(char *)&dis,sizeof(struct DisplayInfo  ),DTAG_DISP,tag->ti_Data);
  583.         dimlen = GetDisplayInfoData(0,(char *)&dim,sizeof(struct DimensionInfo),DTAG_DIMS,tag->ti_Data);
  584.         monlen = GetDisplayInfoData(0,(char *)&mon,sizeof(struct MonitorInfo  ),DTAG_MNTR,tag->ti_Data);
  585.  
  586.         if (dimlen>offset(&dim,&dim.MaxOScan))
  587.         {
  588.             settxt(data->TX_Visible[0],RectangleWidth (dim.MaxOScan));
  589.             settxt(data->TX_Visible[1],RectangleHeight(dim.MaxOScan));
  590.             settxt(data->TX_Minimum[0],dim.MinRasterWidth );
  591.             settxt(data->TX_Minimum[1],dim.MinRasterHeight);
  592.             settxt(data->TX_Maximum[0],dim.MaxRasterWidth );
  593.             settxt(data->TX_Maximum[1],dim.MaxRasterHeight);
  594.             settxt(data->TX_NumColors,1<<dim.MaxDepth);
  595.         }
  596.  
  597.         if (dislen>offset(&dis,&dis.BlueBits))
  598.         {
  599.             DoMethod(data->TX_BitsPerGun,MUIM_SetAsString,MUIA_Text_Contents,"%ld x %ld x %ld",dis.RedBits,dis.GreenBits,dis.BlueBits);
  600.         }
  601.  
  602.         if (monlen>offset(&mon,&mon.TotalColorClocks))
  603.         {
  604.             /* These calculations were taken from ScreenManager by Bernhard "ZZA" Moellemann. Thanks! */
  605.  
  606.             if (mon.TotalRows)
  607.             {
  608.                 ULONG vfreqint=1000000000L/((ULONG)mon.TotalColorClocks*280*mon.TotalRows/1000)+5;
  609.                 DoMethod(data->TX_ScanRate,MUIM_SetAsString,MUIA_Text_Contents,"%ld.%02ld Hz",vfreqint/1000,(vfreqint-(vfreqint/1000)*1000)/10);
  610.             }
  611.             if (mon.TotalColorClocks)
  612.             {
  613.                 ULONG hfreq=1000000000L/((ULONG)mon.TotalColorClocks*280)+5;
  614.                 ULONG hfreqint=hfreq/1000;
  615.                 DoMethod(data->TX_ScanLine,MUIM_SetAsString,MUIA_Text_Contents,"%ld.%02ld kHz",hfreqint,(hfreq-hfreqint*1000)/10);
  616.             }
  617.         }
  618.     }
  619.  
  620.     return(DoSuperMethodA(cl,obj,msg));
  621. }
  622.  
  623. SAVEDS ASM ULONG DispIDinfo_Dispatcher(REG(a0) struct IClass *cl,REG(a2) Object *obj,REG(a1) Msg msg)
  624. {
  625.     switch (msg->MethodID)
  626.     {
  627.         case OM_NEW: return(DispIDinfo_New(cl,obj,(APTR)msg));
  628.         case OM_SET: return(DispIDinfo_Set(cl,obj,(APTR)msg));
  629.     }
  630.     return(DoSuperMethodA(cl,obj,msg));
  631. }
  632.  
  633.  
  634.  
  635. /****************************************************************************/
  636. /* DisplayIDlist class                                                      */
  637. /****************************************************************************/
  638.  
  639. struct DispIDlist_Data
  640. {
  641.     ULONG CurrentID;
  642.     struct Hook ConstructHook;
  643.     struct Hook DisplayHook;
  644. };
  645.  
  646. SAVEDS ASM LONG DispIDlist_DisplayFunc(REG(a2) char **array,REG(a1) struct NameInfo *ni)
  647. {
  648.     *array = ni->Name;
  649.     return(0);
  650. }
  651.  
  652. SAVEDS ASM LONG DispIDlist_CompareFunc(REG(a1) struct NameInfo *n1,REG(a2) struct NameInfo *n2)
  653. {
  654.     return(stricmp(n1->Name,n2->Name));
  655. }
  656.  
  657. SAVEDS ASM VOID DispIDlist_DestructFunc(REG(a1) struct NameInfo *ni)
  658. {
  659.     FreeVec(ni);
  660. }
  661.  
  662. SAVEDS ASM APTR DispIDlist_ConstructFunc(REG(a1) ULONG modeid)
  663. {
  664.     APTR handle;
  665.     struct NameInfo NameInfo;
  666.     struct DisplayInfo DisplayInfo;
  667.     struct DimensionInfo DimensionInfo;
  668.     struct NameInfo *ni;
  669.  
  670.     if ((modeid & MONITOR_ID_MASK)==DEFAULT_MONITOR_ID) return(NULL);
  671.     if (!(handle = FindDisplayInfo(modeid))) return(NULL);
  672.     if (!GetDisplayInfoData(handle,(char *)&NameInfo     ,sizeof(struct NameInfo     ),DTAG_NAME,0)) return(NULL);
  673.     if (!GetDisplayInfoData(handle,(char *)&DisplayInfo  ,sizeof(struct DisplayInfo  ),DTAG_DISP,0)) return(NULL);
  674.     if (!GetDisplayInfoData(handle,(char *)&DimensionInfo,sizeof(struct DimensionInfo),DTAG_DIMS,0)) return(NULL);
  675.     if (!(DisplayInfo.PropertyFlags & DIPF_IS_WB)) return(NULL);
  676.     if (DisplayInfo.NotAvailable) return(NULL);
  677.     if (!(ni = AllocVec(sizeof(struct NameInfo),MEMF_ANY))) return(NULL);
  678.  
  679.     *ni = NameInfo;
  680.     return(ni);
  681. }
  682.  
  683. ULONG DispIDlist_New(struct IClass *cl,Object *obj,Msg msg)
  684. {
  685.     static const struct Hook ConstructHook = { { NULL,NULL },(VOID *)DispIDlist_ConstructFunc,NULL,NULL };
  686.     static const struct Hook DestructHook  = { { NULL,NULL },(VOID *)DispIDlist_DestructFunc ,NULL,NULL };
  687.     static const struct Hook CompareHook   = { { NULL,NULL },(VOID *)DispIDlist_CompareFunc  ,NULL,NULL };
  688.     static const struct Hook DisplayHook   = { { NULL,NULL },(VOID *)DispIDlist_DisplayFunc  ,NULL,NULL };
  689.     LONG id = INVALID_ID;
  690.  
  691.     if (!(obj=(Object *)DoSuperMethodA(cl,obj,msg)))
  692.         return(0);
  693.  
  694.     SetSuperAttrs(cl,obj,
  695.         MUIA_List_ConstructHook, &ConstructHook,
  696.         MUIA_List_DestructHook , &DestructHook,
  697.         MUIA_List_CompareHook  , &CompareHook,
  698.         MUIA_List_DisplayHook  , &DisplayHook,
  699.         MUIA_List_AutoVisible  , TRUE,
  700.         TAG_DONE);
  701.  
  702.     while ((id=NextDisplayInfo(id))!=INVALID_ID)
  703.         DoMethod(obj,MUIM_List_InsertSingle,id,MUIV_List_Insert_Bottom);
  704.  
  705.     DoMethod(obj,MUIM_List_Sort);
  706.  
  707.     DoMethod(obj,MUIM_Notify,MUIA_List_Active,MUIV_EveryTime,obj,1,MUIM_DispIDlist_Change);
  708.  
  709.     return((ULONG)obj);
  710. }
  711.  
  712. ULONG DispIDlist_Set(struct IClass *cl,Object *obj,struct opSet *msg)
  713. {
  714.     struct DispIDlist_Data *data = INST_DATA(cl,obj);
  715.     struct TagItem *tag,*quiet;
  716.  
  717.     quiet = FindTagItem(MUIA_DispIDlist_Quiet,msg->ops_AttrList);
  718.  
  719.     if (tag = FindTagItem(MUIA_DispIDlist_CurrentID,msg->ops_AttrList))
  720.     {
  721.         data->CurrentID = tag->ti_Data;
  722.  
  723.         if (!quiet)
  724.         {
  725.             int i;
  726.             struct NameInfo *ni;
  727.             ULONG mask = 0;
  728.  
  729.             for (;;)
  730.             {
  731.                 for (i=0;;i++)
  732.                 {
  733.                     DoMethod(obj,MUIM_List_GetEntry,i,&ni);
  734.                     if (!ni) break;
  735.                     if ((ni->Header.DisplayID & ~mask)==(data->CurrentID & ~mask)) { mask = MONITOR_ID_MASK; break; }
  736.                 }
  737.                 if (!ni) break;
  738.                 if (mask==MONITOR_ID_MASK) break;
  739.                 mask = MONITOR_ID_MASK;
  740.             }
  741.  
  742.             if (ni)
  743.                 set(obj,MUIA_List_Active,i);
  744.             else
  745.                 set(obj,MUIA_List_Active,MUIV_List_Active_Off);
  746.         }
  747.     }
  748.     return(DoSuperMethodA(cl,obj,msg));
  749. }
  750.  
  751. ULONG DispIDlist_Get(struct IClass *cl,Object *obj,struct opGet *msg)
  752. {
  753.     struct DispIDlist_Data *data = INST_DATA(cl,obj);
  754.  
  755.     switch (msg->opg_AttrID)
  756.     {
  757.         case MUIA_DispIDlist_CurrentID:
  758.             *(msg->opg_Storage) = data->CurrentID;
  759.             return(TRUE);
  760.     }
  761.  
  762.     return(DoSuperMethodA(cl,obj,msg));
  763. }
  764.  
  765. ULONG DispIDlist_Change(struct IClass *cl,Object *obj,Msg msg)
  766. {
  767.     struct NameInfo *ni;
  768.     DoMethod(obj,MUIM_List_GetEntry,MUIV_List_GetEntry_Active,&ni);
  769.     SetAttrs(obj,
  770.         MUIA_DispIDlist_Quiet,TRUE,
  771.         MUIA_DispIDlist_CurrentID,ni ? ni->Header.DisplayID : INVALID_ID,
  772.         TAG_DONE);
  773.     return(0);
  774. }
  775.  
  776. SAVEDS ASM ULONG DispIDlist_Dispatcher(REG(a0) struct IClass *cl,REG(a2) Object *obj,REG(a1) Msg msg)
  777. {
  778.     switch (msg->MethodID)
  779.     {
  780.         case OM_NEW: return(DispIDlist_New(cl,obj,(APTR)msg));
  781.         case OM_SET: return(DispIDlist_Set(cl,obj,(APTR)msg));
  782.         case OM_GET: return(DispIDlist_Get(cl,obj,(APTR)msg));
  783.         case MUIM_DispIDlist_Change: return(DispIDlist_Change(cl,obj,(APTR)msg));
  784.     }
  785.     return(DoSuperMethodA(cl,obj,msg));
  786. }
  787.  
  788.  
  789.  
  790. /****************************************************************************/
  791. /* SysPenField class                                                        */
  792. /****************************************************************************/
  793.  
  794. struct SysPenField_Data
  795. {
  796.     LONG dummy;
  797. };
  798.  
  799.  
  800. ULONG SysPenField_DragQuery(struct IClass *cl,Object *obj,struct MUIP_DragQuery *msg)
  801. {
  802.     if (msg->obj==obj)
  803.         return(MUIV_DragQuery_Refuse);
  804.  
  805.     if (muiUserData(msg->obj)<1 || muiUserData(msg->obj)>8)
  806.         return(MUIV_DragQuery_Refuse);
  807.  
  808.     return(MUIV_DragQuery_Accept);
  809. }
  810.  
  811.  
  812.  
  813. ULONG SysPenField_DragDrop(struct IClass *cl,Object *obj,struct MUIP_DragDrop *msg)
  814. {
  815.     set(obj,MUIA_Pendisplay_Reference,msg->obj);
  816.     return(0);
  817. }
  818.  
  819.  
  820. SAVEDS ASM ULONG SysPenField_Dispatcher(REG(a0) struct IClass *cl,REG(a2) Object *obj,REG(a1) Msg msg)
  821. {
  822.     switch (msg->MethodID)
  823.     {
  824.         case MUIM_DragQuery  : return(SysPenField_DragQuery  (cl,obj,(APTR)msg));
  825.         case MUIM_DragDrop   : return(SysPenField_DragDrop   (cl,obj,(APTR)msg));
  826.     }
  827.     return(DoSuperMethodA(cl,obj,msg));
  828. }
  829.  
  830.  
  831.  
  832. static Object *MakePalette(void)
  833. {
  834.     Object *obj;
  835.  
  836.     obj = MUI_NewObject(MUIC_Poppen,
  837.         MUIA_CycleChain, 1,
  838.         MUIA_Window_Title, "Adjust Color",
  839.         MUIA_Penadjust_PSIMode, 2,
  840.         MUIA_MaxHeight, 20,
  841.         TAG_DONE);
  842.  
  843.     return(obj);
  844. }
  845.  
  846.  
  847. Object *MakeMUIPen(int nr,Object **adr)
  848. {
  849.     Object *obj;
  850.  
  851.     obj = VGroup, MUIA_Group_Spacing, 1,
  852.         Child, *adr = MUI_NewObject(MUIC_Poppen,
  853.             MUIA_CycleChain, 1,
  854.             MUIA_Window_Title, "Adjust MUI Pen",
  855.             MUIA_Penadjust_PSIMode, 1,
  856.             MUIA_MaxHeight, 20,
  857.             TAG_DONE),
  858.         Child, TextObject,
  859.             MUIA_Text_Contents, GetStr(nr),
  860.             MUIA_Text_PreParse, "\33c",
  861.             MUIA_Font, MUIV_Font_Tiny,
  862.             End,
  863.         End;
  864.  
  865.     return(obj);
  866. }
  867.  
  868.  
  869. Object *MakeSysPen(int nr,Object **adr)
  870. {
  871.     Object *obj;
  872.  
  873.     obj = VGroup, MUIA_Group_Spacing, 1,
  874.         Child, *adr = NewObject(CL_SysPenField->mcc_Class,NULL,
  875.             TextFrame,
  876.             MUIA_Background, MUII_BACKGROUND,
  877.             MUIA_InnerLeft  , 4,
  878.             MUIA_InnerRight , 4,
  879.             MUIA_InnerTop   , 4,
  880.             MUIA_InnerBottom, 4,
  881.             TAG_DONE),
  882.         Child, TextObject,
  883.             MUIA_Font, MUIV_Font_Tiny,
  884.             MUIA_Text_Contents, GetStr(nr),
  885.             MUIA_Text_PreParse, "\33c",
  886.             End,
  887.         End;
  888.  
  889.     return(obj);
  890. }
  891.  
  892.  
  893.  
  894.  
  895. /****************************************************************************/
  896. /* EditPanel class                                                          */
  897. /****************************************************************************/
  898.  
  899. #define ForChilds(group) \
  900. {\
  901.     APTR child,cstate;\
  902.     struct MinList *list;\
  903.     get(group,MUIA_Group_ChildList,&list);\
  904.     cstate=list->mlh_Head;\
  905.     while (child=NextObject(&cstate))
  906.  
  907. #define NextChilds }
  908.  
  909. struct EditPanel_Data
  910. {
  911.     Object *TX_Info;
  912.     /*
  913.     Object *CM_Adjustable;
  914.     */
  915.  
  916.     Object *GR_EditPages;
  917.  
  918.     Object *ST_Name;
  919.     Object *ST_Title;
  920.     Object *ST_Font;
  921.     Object *ST_Background;
  922.     Object *CM_AutoScroll;
  923.     Object *CM_NoDrag;
  924.     Object *CM_Exclusive;
  925.     Object *CM_Interleaved;
  926.     Object *CM_Behind;
  927.     Object *CM_SysDefault;
  928.     Object *CM_AutoClose;
  929.     Object *CM_CloseGadget;
  930.  
  931.     Object *GR_Size;
  932.     Object *LV_Modes;
  933.     Object *LI_Modes;
  934.     Object *CY_Overscan;
  935.     Object *ST_Width;
  936.     Object *ST_Height;
  937.     Object *SL_Depth;
  938.     Object *TX_ModeInfo;
  939.  
  940.     Object *palette[PSD_NUMCOLS];
  941.     Object *syspens[PSD_NUMSYSPENS];
  942.     /*Object *muipens[PSD_NUMMUIPENS];*/
  943.     Object *ColorMenu;
  944.  
  945.     LONG update;
  946. };
  947.  
  948.  
  949. ULONG EditPanel_SetScreen(struct IClass *cl,Object *obj,struct MUIP_EditPanel_SetScreen *msg)
  950. {
  951.     struct EditPanel_Data *data = INST_DATA(cl,obj);
  952.     struct MUI_PubScreenDesc *desc = msg->desc;
  953.     int i;
  954.  
  955.     set(data->ST_Name       ,MUIA_String_Contents ,desc->Name      );
  956.     set(data->ST_Title      ,MUIA_String_Contents ,desc->Title     );
  957.     set(data->ST_Font       ,MUIA_String_Contents ,desc->Font      );
  958.     set(data->ST_Background ,MUIA_String_Contents ,desc->Background);
  959.  
  960.     /*
  961.     set(data->CM_Adjustable ,MUIA_Selected       ,!desc->Foreign   );
  962.     */
  963.     set(data->CM_AutoScroll ,MUIA_Selected       ,desc->AutoScroll );
  964.     set(data->CM_NoDrag     ,MUIA_Selected       ,desc->NoDrag     );
  965.     set(data->CM_Exclusive  ,MUIA_Selected       ,desc->Exclusive  );
  966.     set(data->CM_Interleaved,MUIA_Selected       ,desc->Interleaved);
  967.     set(data->CM_SysDefault ,MUIA_Selected       ,desc->SysDefault );
  968.     set(data->CM_Behind     ,MUIA_Selected       ,desc->Behind     );
  969.     set(data->CM_AutoClose  ,MUIA_Selected       ,desc->AutoClose  );
  970.     set(data->CM_CloseGadget,MUIA_Selected       ,desc->CloseGadget);
  971.  
  972.     set(data->LI_Modes,MUIA_DispIDlist_CurrentID,desc->DisplayID);
  973.  
  974.     setstr(data->ST_Width ,desc->DisplayWidth );
  975.     setstr(data->ST_Height,desc->DisplayHeight);
  976.     set(data->SL_Depth,MUIA_Slider_Level,desc->DisplayDepth);
  977.     set(data->CY_Overscan,MUIA_Cycle_Active,desc->OverscanType);
  978.  
  979.     for (i=0;i<PSD_NUMCOLS;i++)
  980.     {
  981.         set(data->palette[i],MUIA_Pendisplay_RGBcolor,&desc->Palette[i]);
  982.     }
  983.  
  984.     /*
  985.     for (i=0;i<PSD_NUMMUIPENS;i++)
  986.     {
  987.         set(data->muipens[i],MUIA_Pendisplay_Spec,&desc->MUIPens[i]);
  988.     }
  989.     */
  990.  
  991.     for (i=0;i<PSD_NUMSYSPENS;i++)
  992.     {
  993.         if (data->syspens[i])
  994.         {
  995.             BYTE p = desc->SystemPens[i];
  996.             p = BETWEEN(0,p,3) ? p : BETWEEN(-4,p,-1) ? 8+p : 0;
  997.             set(data->syspens[i],MUIA_Pendisplay_Reference,data->palette[p]);
  998.         }
  999.     }
  1000.  
  1001.     return(0);
  1002. }
  1003.  
  1004.  
  1005. ULONG EditPanel_GetScreen(struct IClass *cl,Object *obj,struct MUIP_EditPanel_GetScreen *msg)
  1006. {
  1007.     struct EditPanel_Data *data = INST_DATA(cl,obj);
  1008.     struct MUI_PubScreenDesc *desc = msg->desc;
  1009.     int i;
  1010.  
  1011.     strcpy(desc->Name      ,getstr(data->ST_Name      ));
  1012.     strcpy(desc->Title     ,getstr(data->ST_Title     ));
  1013.     strcpy(desc->Font      ,getstr(data->ST_Font      ));
  1014.     strcpy(desc->Background,getstr(data->ST_Background));
  1015.  
  1016.     /*
  1017.     desc->Foreign     = !getbool(data->CM_Adjustable );
  1018.     */
  1019.     desc->AutoScroll  = getbool(data->CM_AutoScroll );
  1020.     desc->NoDrag      = getbool(data->CM_NoDrag     );
  1021.     desc->Exclusive   = getbool(data->CM_Exclusive  );
  1022.     desc->Interleaved = getbool(data->CM_Interleaved);
  1023.     desc->SysDefault  = getbool(data->CM_SysDefault );
  1024.     desc->Behind      = getbool(data->CM_Behind     );
  1025.     desc->AutoClose   = getbool(data->CM_AutoClose  );
  1026.     desc->CloseGadget = getbool(data->CM_CloseGadget);
  1027.  
  1028.     desc->DisplayID     = xget(data->LI_Modes,MUIA_DispIDlist_CurrentID);
  1029.     desc->DisplayWidth  = atol(getstr(data->ST_Width ));
  1030.     desc->DisplayHeight = atol(getstr(data->ST_Height));
  1031.  
  1032.     desc->DisplayDepth  = xget(data->SL_Depth,MUIA_Slider_Level);
  1033.     desc->OverscanType  = xget(data->CY_Overscan,MUIA_Cycle_Active);
  1034.  
  1035.     for (i=0;i<PSD_NUMCOLS;i++)
  1036.     {
  1037.         desc->Palette[i] = *((struct MUI_RGBcolor *)xget(data->palette[i],MUIA_Pendisplay_RGBcolor));
  1038.     }
  1039.  
  1040.     /*
  1041.     for (i=0;i<PSD_NUMMUIPENS;i++)
  1042.     {
  1043.         desc->MUIPens[i] = *((struct MUI_PenSpec *)xget(data->muipens[i],MUIA_Pendisplay_Spec));
  1044.     }
  1045.     */
  1046.  
  1047.     for (i=0;i<PSD_NUMSYSPENS;i++)
  1048.     {
  1049.         if (data->syspens[i])
  1050.         {
  1051.             BYTE p = muiUserData(xget(data->syspens[i],MUIA_Pendisplay_Reference));
  1052.             desc->SystemPens[i] = BETWEEN(1,p,4) ? p-1 : p-9;
  1053.         }
  1054.     }
  1055.  
  1056.     return(0);
  1057. }
  1058.  
  1059.  
  1060. ULONG EditPanel_ContextMenuChoice(struct IClass *cl,Object *obj,struct MUIP_ContextMenuChoice *msg)
  1061. {
  1062.     struct PalettePreset
  1063.     {
  1064.         struct MUI_RGBcolor col[8];
  1065.     };
  1066.  
  1067.     static const struct PalettePreset PalettePreset[10] =
  1068.     {
  1069.         /* def */
  1070.         {
  1071.             {
  1072.             { 0xAAAAAAAA,0xAAAAAAAA,0xAAAAAAAA },
  1073.             { 0x00000000,0x00000000,0x00000000 },
  1074.             { 0xFFFFFFFF,0xFFFFFFFF,0xFFFFFFFF },
  1075.             { 0x66666666,0x88888888,0xBBBBBBBB },
  1076.             { 0xEEEEEEEE,0x44444444,0x44444444 },
  1077.             { 0x55555555,0xDDDDDDDD,0x55555555 },
  1078.             { 0x00000000,0x44444444,0xDDDDDDDD },
  1079.             { 0xEEEEEEEE,0x99999999,0x00000000 },
  1080.             }
  1081.         },
  1082.         /* tint */
  1083.         {
  1084.             {
  1085.             { 0xCCCCCCCC,0xCCCCCCCC,0xBBBBBBBB },
  1086.             { 0x00000000,0x00000000,0x33333333 },
  1087.             { 0xFFFFFFFF,0xFFFFFFFF,0xFFFFFFFF },
  1088.             { 0x99999999,0xAAAAAAAA,0xBBBBBBBB },
  1089.             { 0xEEEEEEEE,0x44444444,0x44444444 },
  1090.             { 0x55555555,0xDDDDDDDD,0x55555555 },
  1091.             { 0xE0E0E0E0,0xF0F0F0F0,0x88888888 },
  1092.             { 0x00000000,0x44444444,0xDDDDDDDD },
  1093.             }
  1094.         },
  1095.         /* pharao */
  1096.         {
  1097.             {
  1098.             { 0x55555555,0xBBBBBBBB,0xAAAAAAAA },
  1099.             { 0x00000000,0x00000000,0x22222222 },
  1100.             { 0xEEEEEEEE,0xEEEEEEEE,0xFFFFFFFF },
  1101.             { 0x55555555,0x77777777,0xAAAAAAAA },
  1102.             { 0xF6F6F6F6,0xF6F6F6F6,0x00000000 },
  1103.             { 0x62626262,0x51515151,0xF0F0F0F0 },
  1104.             { 0x00000000,0xF0F0F0F0,0x00000000 },
  1105.             { 0xF0F0F0F0,0x30303030,0x10101010 },
  1106.             }
  1107.         },
  1108.         /* sunset */
  1109.         {
  1110.             {
  1111.             { 0xAAAAAAAA,0x99999999,0x88888888 },
  1112.             { 0x33333333,0x22222222,0x11111111 },
  1113.             { 0xFFFFFFFF,0xEEEEEEEE,0xEEEEEEEE },
  1114.             { 0xFFFFFFFF,0xDDDDDDDD,0xBBBBBBBB },
  1115.             { 0xEEEEEEEE,0x44444444,0x44444444 },
  1116.             { 0x55555555,0xDDDDDDDD,0x55555555 },
  1117.             { 0xCFCFCFCF,0xDBDBDBDB,0xFFFFFFFF },
  1118.             { 0x00000000,0x44444444,0xDDDDDDDD },
  1119.             }
  1120.         },
  1121.         /* ocean */
  1122.         {
  1123.             {
  1124.             { 0x88888888,0xAAAAAAAA,0xCCCCCCCC },
  1125.             { 0x00000000,0x00000000,0x22222222 },
  1126.             { 0xFFFFFFFF,0xFFFFFFFF,0xFFFFFFFF },
  1127.             { 0xFFFFFFFF,0xCCCCCCCC,0x99999999 },
  1128.             { 0x00000000,0x00000000,0xF0F0F0F0 },
  1129.             { 0xF9F9F9F9,0x21212121,0x21212121 },
  1130.             { 0x52525252,0xF2F2F2F2,0x76767676 },
  1131.             { 0xDFDFDFDF,0xA5A5A5A5,0x26262626 },
  1132.             }
  1133.         },
  1134.         /* steel */
  1135.         {
  1136.             {
  1137.             { 0x99999999,0xBBBBBBBB,0xDDDDDDDD },
  1138.             { 0x00000000,0x00000000,0x22222222 },
  1139.             { 0xFFFFFFFF,0xFFFFFFFF,0xFFFFFFFF },
  1140.             { 0x66666666,0x88888888,0xBBBBBBBB },
  1141.             { 0xB2B2B2B2,0xDEDEDEDE,0xFFFFFFFF },
  1142.             { 0xFFFFFFFF,0xA1A1A1A1,0x1C1C1C1C },
  1143.             { 0xF0F0F0F0,0x44444444,0x87878787 },
  1144.             { 0xBFBFBFBF,0xFFFFFFFF,0x90909090 },
  1145.             }
  1146.         },
  1147.         /* chocolate */
  1148.         {
  1149.             {
  1150.             { 0xBBBBBBBB,0xAAAAAAAA,0x99999999 },
  1151.             { 0x00000000,0x00000000,0x22222222 },
  1152.             { 0xFFFFFFFF,0xFFFFFFFF,0xFFFFFFFF },
  1153.             { 0x66666666,0x88888888,0xBBBBBBBB },
  1154.             { 0xEEEEEEEE,0x44444444,0x44444444 },
  1155.             { 0x55555555,0xDDDDDDDD,0x55555555 },
  1156.             { 0x00000000,0x44444444,0xDDDDDDDD },
  1157.             { 0xEEEEEEEE,0x99999999,0x00000000 },
  1158.             }
  1159.         },
  1160.         /* pewter */
  1161.         {
  1162.             {
  1163.             { 0x88888888,0xAAAAAAAA,0xCCCCCCCC },
  1164.             { 0x00000000,0x00000000,0x22222222 },
  1165.             { 0xFFFFFFFF,0xFFFFFFFF,0xFFFFFFFF },
  1166.             { 0xEEEEEEEE,0x99999999,0x77777777 },
  1167.             { 0xD9D9D9D9,0xFFFFFFFF,0x09090909 },
  1168.             { 0xF0F0F0F0,0x2D2D2D2D,0x31313131 },
  1169.             { 0x38383838,0xF2F2F2F2,0x38383838 },
  1170.             { 0x44444444,0x49494949,0xF0F0F0F0 },
  1171.             }
  1172.         },
  1173.         /* wine */
  1174.         {
  1175.             {
  1176.             { 0xCCCCCCCC,0x99999999,0x99999999 },
  1177.             { 0x00000000,0x00000000,0x22222222 },
  1178.             { 0xFFFFFFFF,0xEEEEEEEE,0xEEEEEEEE },
  1179.             { 0xBBBBBBBB,0x66666666,0x77777777 },
  1180.             { 0xE0E0E0E0,0xF0F0F0F0,0x88888888 },
  1181.             { 0x79797979,0x46464646,0xE8E8E8E8 },
  1182.             { 0x60606060,0xC7C7C7C7,0x52525252 },
  1183.             { 0x89898989,0xEAEAEAEA,0xC8C8C8C8 },
  1184.             }
  1185.         },
  1186.         /* magicwb */
  1187.         {
  1188.             {
  1189.             { 0x95959595,0x95959595,0x95959595 },
  1190.             { 0x00000000,0x00000000,0x00000000 },
  1191.             { 0xffffffff,0xffffffff,0xffffffff },
  1192.             { 0x3b3b3b3b,0x67676767,0xa2a2a2a2 },
  1193.             { 0x7b7b7b7b,0x7b7b7b7b,0x7b7b7b7b },
  1194.             { 0xafafafaf,0xafafafaf,0xafafafaf },
  1195.             { 0xaaaaaaaa,0x90909090,0x7c7c7c7c },
  1196.             { 0xffffffff,0xa9a9a9a9,0x97979797 },
  1197.             }
  1198.         },
  1199.     };
  1200.     /*{   0, 1, 1, 2, 1, 3, 1, 0, 2, 1, 2, 1 }*/
  1201.  
  1202.     LONG i = muiUserData(msg->item);
  1203.     struct MUI_PubScreenDesc *desc = NULL;
  1204.     struct MUI_RGBcolor *new = NULL;
  1205.     struct EditPanel_Data *data = INST_DATA(cl,obj);
  1206.  
  1207.     if (i>=0 && i<10)
  1208.     {
  1209.         new = (struct MUI_RGBcolor *)PalettePreset[i].col;
  1210.     }
  1211.     else if (i==10)
  1212.     {
  1213.         if (desc = MUIS_AllocPubScreenDesc(NULL))
  1214.         {
  1215.             new = desc->Palette;
  1216.         }
  1217.     }
  1218.  
  1219.     if (new)
  1220.     {
  1221.         for (i=0;i<PSD_NUMCOLS;i++)
  1222.         {
  1223.             set(data->palette[i],MUIA_Pendisplay_RGBcolor,&new[i]);
  1224.         }
  1225.     }
  1226.  
  1227.     if (desc)
  1228.         MUIS_FreePubScreenDesc(desc);
  1229.  
  1230.     return(0);
  1231. }
  1232.  
  1233.  
  1234. ULONG EditPanel_New(struct IClass *cl,Object *obj,struct opSet *msg)
  1235. {
  1236.     struct EditPanel_Data tmp = {0};
  1237.     Object *l1,*l2;
  1238.  
  1239.     obj = (Object *)DoSuperNew(cl,obj,
  1240.         MUIA_Group_Horiz, FALSE,
  1241.  
  1242.         MUIA_ContextMenu, tmp.ColorMenu = MUI_MakeObject(MUIO_MenustripNM,PaletteMenu,MUIO_MenustripNM_CommandKeyCheck),
  1243.  
  1244.         /*
  1245.         Child, HGroup, GroupSpacing(1),
  1246.             MUIA_Weight, 0,
  1247.             */
  1248.             Child, tmp.TX_Info = TextObject,TextFrame,MUIA_Background,MUII_TextBack,MUIA_Text_PreParse,"\33c",End,
  1249.             /*
  1250.             Child, tmp.CM_Adjustable = MUI_MakeObject(MUIO_Checkmark,NULL),
  1251.             End,
  1252.             */
  1253.  
  1254.         Child, tmp.GR_EditPages = RegisterGroup(CYA_EditPages),
  1255.             MUIA_CycleChain, 1,
  1256.  
  1257.             Child, ColGroup(2),
  1258.                 Child, MakeLabel2(MSG_LABEL_PUBLICNAME),
  1259.                 Child, tmp.ST_Name = MUI_NewObject(MUIC_Popscreen,
  1260.                     MUIA_Popstring_String, MakeString(PSD_MAXLEN_NAME,MSG_LABEL_PUBLICNAME),
  1261.                     MUIA_Popstring_Button, PopButton(MUII_PopUp),
  1262.                     TAG_DONE),
  1263.                 Child, MakeLabel2(MSG_LABEL_SCREENTITLE), Child, tmp.ST_Title = MakeString(PSD_MAXLEN_TITLE,MSG_LABEL_SCREENTITLE),
  1264.                 Child, MakeLabel2(MSG_LABEL_DEFAULTFONT), Child, tmp.ST_Font  = PopaslObject, MUIA_Popstring_String, MakeString(PSD_MAXLEN_FONT,MSG_LABEL_DEFAULTFONT), MUIA_Popstring_Button, PopButton(MUII_PopUp), MUIA_Popasl_Type, ASL_FontRequest, End,
  1265.                 Child, MakeLabel2(MSG_LABEL_BACKGROUND ), Child, tmp.ST_Background = PopaslObject, MUIA_Popstring_String, MakeString(PSD_MAXLEN_BACKGROUND,MSG_LABEL_BACKGROUND), MUIA_Popstring_Button, PopButton(MUII_PopUp), MUIA_Popasl_Type, ASL_FileRequest, End,
  1266.                 Child, VSpace(2), Child, VSpace(2),
  1267.                 Child, MakeFreeLabel(MSG_LABEL_PUBLICFLAGS),
  1268.                 Child, HGroup,
  1269.                     Child, ColGroup(2),
  1270.                         Child, tmp.CM_AutoScroll  = MakeCheck(MSG_LABEL_AUTOSCROLL   ), Child, MakeLLabel1(MSG_LABEL_AUTOSCROLL   ),
  1271.                         Child, tmp.CM_NoDrag      = MakeCheck(MSG_LABEL_NODRAG       ), Child, MakeLLabel1(MSG_LABEL_NODRAG       ),
  1272.                         Child, tmp.CM_Exclusive   = MakeCheck(MSG_LABEL_EXCLUSIVE    ), Child, MakeLLabel1(MSG_LABEL_EXCLUSIVE    ),
  1273.                         End,
  1274.                     Child, HSpace(0),
  1275.                     Child, ColGroup(2),
  1276.                         Child, tmp.CM_AutoClose   = MakeCheck(MSG_LABEL_AUTOCLOSE    ), Child, MakeLLabel1(MSG_LABEL_AUTOCLOSE    ),
  1277.                         Child, tmp.CM_Interleaved = MakeCheck(MSG_LABEL_INTERLEAVED  ), Child, MakeLLabel1(MSG_LABEL_INTERLEAVED  ),
  1278.                         Child, tmp.CM_Behind      = MakeCheck(MSG_LABEL_OPENBEHIND   ), Child, MakeLLabel1(MSG_LABEL_OPENBEHIND   ),
  1279.                         End,
  1280.                     Child, HSpace(0),
  1281.                     Child, ColGroup(2),
  1282.                         Child, tmp.CM_SysDefault  = MakeCheck(MSG_LABEL_SYSTEMDEFAULT), Child, MakeLLabel1(MSG_LABEL_SYSTEMDEFAULT),
  1283.                         Child, tmp.CM_CloseGadget = MakeCheck(MSG_LABEL_CLOSEGADGET  ), Child, MakeLLabel1(MSG_LABEL_CLOSEGADGET  ),
  1284.                         Child, VSpace(0), Child, VSpace(0),
  1285.                         End,
  1286.                     End,
  1287.                 End,
  1288.  
  1289.             Child, HGroup,
  1290.                 Child, tmp.LV_Modes = ListviewObject,
  1291.                     MUIA_CycleChain, 1,
  1292.                     MUIA_Listview_List, tmp.LI_Modes = NewObject(CL_DispIDlist->mcc_Class,NULL,
  1293.                         InputListFrame,
  1294.                         MUIA_List_AdjustWidth, TRUE,
  1295.                         TAG_DONE),
  1296.                     End,
  1297.                 Child, VGroup,
  1298.                     Child, ScrollgroupObject,
  1299.                         MUIA_Scrollgroup_FreeHoriz, FALSE,
  1300.                   MUIA_Scrollgroup_Contents, VirtgroupObject,
  1301.                             TextFrame,
  1302.                             GroupSpacing(0),
  1303.                             MUIA_Group_Horiz, TRUE,
  1304.                             Child, tmp.TX_ModeInfo = NewObject(CL_DispIDinfo->mcc_Class,NULL,TAG_DONE),
  1305.                             Child, HSpace(0),
  1306.                             End,
  1307.                         End,
  1308.                     Child, RectangleObject, MUIA_VertWeight, 1, End,
  1309.                     Child, tmp.GR_Size = ColGroup(2),
  1310.                         Child, MakeLabel1(MSG_LABEL_OVERSCAN), Child, tmp.CY_Overscan = MakeCycle(CYA_Overscan,MSG_LABEL_OVERSCAN),
  1311.                         Child, MakeLabel2(MSG_LABEL_SIZE),
  1312.                         Child, HGroup,
  1313.                             Child, tmp.ST_Width = MakeString(8,MSG_LABEL_SIZE),
  1314.                             Child, MakeLabel2(MSG_LABEL_CROSS),
  1315.                             Child, tmp.ST_Height = MakeString(8,MSG_LABEL_CROSS),
  1316.                             End,
  1317.                         Child, MakeLabel2(MSG_LABEL_DEPTH), Child, tmp.SL_Depth = MakeSlider(1,24,MSG_LABEL_DEPTH),
  1318.                         End,
  1319.                     End,
  1320.                 End,
  1321.  
  1322.             Child, VGroup,
  1323.                 Child, ColGroup(3),
  1324.                     GroupFrameT(GetStr(MSG_PALETTE_TITLE)),
  1325.                     MUIA_Group_VertSpacing, 1,
  1326.                     Child, l1 = MakeCLabel(MSG_PALETTE_FIRST),
  1327.                     Child, HSpace(4),
  1328.                     Child, l2 = MakeCLabel(MSG_PALETTE_LAST),
  1329.                     Child, HGroup,
  1330.                         Child, tmp.palette[0] = MakePalette(),
  1331.                         Child, tmp.palette[1] = MakePalette(),
  1332.                         Child, tmp.palette[2] = MakePalette(),
  1333.                         Child, tmp.palette[3] = MakePalette(),
  1334.                         End,
  1335.                     Child, HSpace(4),
  1336.                     Child, HGroup,
  1337.                         Child, tmp.palette[4] = MakePalette(),
  1338.                         Child, tmp.palette[5] = MakePalette(),
  1339.                         Child, tmp.palette[6] = MakePalette(),
  1340.                         Child, tmp.palette[7] = MakePalette(),
  1341.                         End,
  1342.                     End,
  1343.                 Child, HGroup,
  1344.                     Child, ColGroup(3),
  1345.                         GroupFrameT(GetStr(MSG_SYSPENS_TITLE)),
  1346.                         Child, MakeSysPen(MSG_SYSPEN_TEXT     ,&tmp.syspens[TEXTPEN         ]),
  1347.                         Child, MakeSysPen(MSG_SYSPEN_SHINE    ,&tmp.syspens[SHINEPEN        ]),
  1348.                         Child, MakeSysPen(MSG_SYSPEN_SHADOW   ,&tmp.syspens[SHADOWPEN       ]),
  1349.                         Child, MakeSysPen(MSG_SYSPEN_FILL     ,&tmp.syspens[FILLPEN         ]),
  1350.                         Child, MakeSysPen(MSG_SYSPEN_FILLTEXT ,&tmp.syspens[FILLTEXTPEN     ]),
  1351.                         Child, MakeSysPen(MSG_SYSPEN_HIGHLIGHT,&tmp.syspens[HIGHLIGHTTEXTPEN]),
  1352.                         Child, MakeSysPen(MSG_SYSPEN_BARDETAIL,&tmp.syspens[BARDETAILPEN    ]),
  1353.                         Child, MakeSysPen(MSG_SYSPEN_BARBLOCK ,&tmp.syspens[BARBLOCKPEN     ]),
  1354.                         Child, MakeSysPen(MSG_SYSPEN_BARTRIM  ,&tmp.syspens[BARTRIMPEN      ]),
  1355.                         End,
  1356.                     /*
  1357.                     Child, VGroup,
  1358.                         GroupFrameT(GetStr(MSG_MUIPENS_TITLE)),
  1359.                         Child, ColGroup(3),
  1360.                             Child, MakeMUIPen(MSG_MUIPEN_SHINE     ,&tmp.muipens[MPEN_SHINE     ]),
  1361.                             Child, MakeMUIPen(MSG_MUIPEN_HALFSHINE ,&tmp.muipens[MPEN_HALFSHINE ]),
  1362.                             Child, MakeMUIPen(MSG_MUIPEN_BACKGROUND,&tmp.muipens[MPEN_BACKGROUND]),
  1363.                             Child, MakeMUIPen(MSG_MUIPEN_HALFSHADOW,&tmp.muipens[MPEN_HALFSHADOW]),
  1364.                             Child, MakeMUIPen(MSG_MUIPEN_SHADOW    ,&tmp.muipens[MPEN_SHADOW    ]),
  1365.                             Child, MakeMUIPen(MSG_MUIPEN_TEXT      ,&tmp.muipens[MPEN_TEXT      ]),
  1366.                             Child, MakeMUIPen(MSG_MUIPEN_FILL      ,&tmp.muipens[MPEN_FILL      ]),
  1367.                             Child, MakeMUIPen(MSG_MUIPEN_MARK      ,&tmp.muipens[MPEN_MARK      ]),
  1368.                             End,
  1369.                         End,
  1370.                     */
  1371.                     End,
  1372.                 End,
  1373.  
  1374.             End,
  1375.         TAG_MORE,msg->ops_AttrList);
  1376.  
  1377.     if (obj)
  1378.     {
  1379.         struct EditPanel_Data *data = INST_DATA(cl,obj);
  1380.         int i;
  1381.  
  1382.         *data = tmp;
  1383.  
  1384.         DoMethod(tmp.LI_Modes     ,MUIM_Notify,MUIA_DispIDlist_CurrentID,MUIV_EveryTime,obj,2,MUIM_EditPanel_Update,3);
  1385.         DoMethod(tmp.CY_Overscan  ,MUIM_Notify,MUIA_Cycle_Active        ,MUIV_EveryTime,obj,2,MUIM_EditPanel_Update,2);
  1386.         DoMethod(tmp.ST_Width     ,MUIM_Notify,MUIA_String_Acknowledge  ,MUIV_EveryTime,obj,2,MUIM_EditPanel_Update,1);
  1387.         DoMethod(tmp.ST_Height    ,MUIM_Notify,MUIA_String_Acknowledge  ,MUIV_EveryTime,obj,2,MUIM_EditPanel_Update,1);
  1388.         DoMethod(tmp.SL_Depth     ,MUIM_Notify,MUIA_Slider_Level        ,MUIV_EveryTime,obj,2,MUIM_EditPanel_Update,1);
  1389.  
  1390.         /*
  1391.         set(tmp.CM_Adjustable,MUIA_Selected,TRUE);
  1392.         DoMethod(tmp.CM_Adjustable,MUIM_Notify,MUIA_Selected            ,MUIV_EveryTime,obj,1,MUIM_EditPanel_ToggleForeign);
  1393.         */
  1394.  
  1395.         set(tmp.TX_Info       ,MUIA_ShortHelp,GetStr(MSG_HELP_INFO         ));
  1396.         /*
  1397.         set(tmp.CM_Adjustable ,MUIA_ShortHelp,GetStr(MSG_HELP_ADJUSTABLE   ));
  1398.         */
  1399.         set(tmp.ST_Name       ,MUIA_ShortHelp,GetStr(MSG_HELP_NAME         ));
  1400.         set(tmp.ST_Title      ,MUIA_ShortHelp,GetStr(MSG_HELP_TITLE        ));
  1401.         set(tmp.ST_Font       ,MUIA_ShortHelp,GetStr(MSG_HELP_FONT         ));
  1402.         set(tmp.ST_Background ,MUIA_ShortHelp,GetStr(MSG_HELP_BACKGROUND   ));
  1403.         set(tmp.CM_AutoScroll ,MUIA_ShortHelp,GetStr(MSG_HELP_AUTOSCROLL   ));
  1404.         set(tmp.CM_NoDrag     ,MUIA_ShortHelp,GetStr(MSG_HELP_NODRAG       ));
  1405.         set(tmp.CM_Exclusive  ,MUIA_ShortHelp,GetStr(MSG_HELP_EXCLUSIVE    ));
  1406.         set(tmp.CM_Interleaved,MUIA_ShortHelp,GetStr(MSG_HELP_INTERLEAVED  ));
  1407.         set(tmp.CM_Behind     ,MUIA_ShortHelp,GetStr(MSG_HELP_BEHIND       ));
  1408.         set(tmp.CM_AutoClose  ,MUIA_ShortHelp,GetStr(MSG_HELP_AUTOCLOSE    ));
  1409.         set(tmp.CM_CloseGadget,MUIA_ShortHelp,GetStr(MSG_HELP_CLOSEGADGET  ));
  1410.         set(tmp.CM_SysDefault ,MUIA_ShortHelp,GetStr(MSG_HELP_SYSTEMDEFAULT));
  1411.         set(tmp.LV_Modes      ,MUIA_ShortHelp,GetStr(MSG_HELP_MODELIST     ));
  1412.         set(tmp.CY_Overscan   ,MUIA_ShortHelp,GetStr(MSG_HELP_OVERSCAN     ));
  1413.         set(tmp.ST_Width      ,MUIA_ShortHelp,GetStr(MSG_HELP_WIDTH        ));
  1414.         set(tmp.ST_Height     ,MUIA_ShortHelp,GetStr(MSG_HELP_HEIGHT       ));
  1415.         set(tmp.SL_Depth      ,MUIA_ShortHelp,GetStr(MSG_HELP_DEPTH        ));
  1416.         set(tmp.TX_ModeInfo   ,MUIA_ShortHelp,GetStr(MSG_HELP_MODEINFO     ));
  1417.  
  1418.         for (i=0;i<8;i++)
  1419.             set(data->palette[i],MUIA_UserData,i+1);
  1420.  
  1421.         set(l1,MUIA_Font,MUIV_Font_Tiny);
  1422.         set(l2,MUIA_Font,MUIV_Font_Tiny);
  1423.  
  1424.         /*
  1425.         DoMethod(obj,MUIM_EditPanel_ToggleForeign);
  1426.         */
  1427.  
  1428.         if (IntuitionBase->lib_Version<39)
  1429.             set(tmp.ST_Background,MUIA_Disabled,TRUE);
  1430.  
  1431.         return((ULONG)obj);
  1432.     }
  1433.  
  1434.     return(0);
  1435. }
  1436.  
  1437.  
  1438. ULONG EditPanel_Dispose(struct IClass *cl,Object *obj,Msg msg)
  1439. {
  1440.     struct EditPanel_Data *data = INST_DATA(cl,obj);
  1441.  
  1442.     if (data->ColorMenu)
  1443.         MUI_DisposeObject(data->ColorMenu);
  1444.  
  1445.     return(DoSuperMethodA(cl,obj,msg));
  1446. }
  1447.  
  1448.  
  1449. /*
  1450. ULONG EditPanel_ToggleForeign(struct IClass *cl,Object *obj,Msg msg)
  1451. {
  1452.     struct EditPanel_Data *data = INST_DATA(cl,obj);
  1453.     BOOL disable = !getbool(data->CM_Adjustable);
  1454.  
  1455.     if (disable)
  1456.         set(data->GR_EditPages,MUIA_Group_ActivePage,2);
  1457.  
  1458.     DoMethod(obj,MUIM_EditPanel_Update,1);
  1459.  
  1460.     DoMethod(obj,MUIM_MultiSet,MUIA_Disabled,disable,
  1461.         data->ST_Title,
  1462.         data->ST_Font,
  1463.         data->ST_Background,
  1464.         data->CM_AutoScroll,
  1465.         data->CM_NoDrag,
  1466.         data->CM_Exclusive,
  1467.         data->CM_Interleaved,
  1468.         data->CM_Behind,
  1469.         data->CM_SysDefault,
  1470.         data->CM_AutoClose,
  1471.         data->CM_CloseGadget,
  1472.         data->LV_Modes,
  1473.         data->CY_Overscan,
  1474.         data->ST_Width,
  1475.         data->ST_Height,
  1476.         data->SL_Depth,
  1477.         data->TX_ModeInfo,
  1478.         NULL);
  1479.  
  1480.     return(0);
  1481. }
  1482. */
  1483.  
  1484.  
  1485. ULONG EditPanel_Update(struct IClass *cl,Object *obj,struct MUIP_EditPanel_Update *msg)
  1486. {
  1487.     struct EditPanel_Data *data = INST_DATA(cl,obj);
  1488.     struct NameInfo *ni;
  1489.     struct DimensionInfo DimensionInfo;
  1490.  
  1491.     if (data->update) return(0);
  1492.     data->update = TRUE;
  1493.  
  1494.     /*
  1495.     if (getbool(data->CM_Adjustable))
  1496.     */
  1497.     {
  1498.         DoMethod(data->LI_Modes,MUIM_List_GetEntry,MUIV_List_GetEntry_Active,&ni);
  1499.  
  1500.         if (ni && GetDisplayInfoData(NULL,(char *)&DimensionInfo,sizeof(DimensionInfo),DTAG_DIMS,ni->Header.DisplayID))
  1501.         {
  1502.             /*set(data->GR_SysPots,MUIA_Coloradjust_ModeID,ni->Header.DisplayID); !!!*/
  1503.  
  1504.             if (msg->level>=1)
  1505.             {
  1506.                 set(data->GR_Size,MUIA_Disabled,FALSE);
  1507.                 set(data->SL_Depth,MUIA_Slider_Max,DimensionInfo.MaxDepth);
  1508.             }
  1509.  
  1510.             if (msg->level>=3)
  1511.                 set(data->TX_ModeInfo,MUIA_DispIDinfo_ID,ni->Header.DisplayID);
  1512.  
  1513.             if (msg->level>=2)
  1514.             {
  1515.                 int w = RectangleWidth(DimensionInfo.TxtOScan);
  1516.                 int h = RectangleHeight(DimensionInfo.TxtOScan);
  1517.  
  1518.                 switch (xget(data->CY_Overscan,MUIA_Cycle_Active))
  1519.                 {
  1520.                     case 1:
  1521.                         w = RectangleWidth(DimensionInfo.StdOScan);
  1522.                         h = RectangleHeight(DimensionInfo.StdOScan);
  1523.                         break;
  1524.  
  1525.                     case 2:
  1526.                         w = RectangleWidth(DimensionInfo.MaxOScan);
  1527.                         h = RectangleHeight(DimensionInfo.MaxOScan);
  1528.                         break;
  1529.  
  1530.                     case 3:
  1531.                         w = RectangleWidth(DimensionInfo.VideoOScan);
  1532.                         h = RectangleHeight(DimensionInfo.VideoOScan);
  1533.                         break;
  1534.                 }
  1535.  
  1536.                 setstr(data->ST_Width ,w);
  1537.                 setstr(data->ST_Height,h);
  1538.             }
  1539.  
  1540.             if (msg->level>=1)
  1541.                 DoMethod(data->TX_Info,MUIM_SetAsString,MUIA_Text_Contents,"%s (%ld x %ld x %ld)",ni->Name,atol(getstr(data->ST_Width)),atol(getstr(data->ST_Height)),xget(data->SL_Depth,MUIA_Slider_Level));
  1542.         }
  1543.         else
  1544.         {
  1545.             /* set(data->GR_SysPots,MUIA_Coloradjust_ModeID,INVALID_ID); !!!*/
  1546.             set(data->TX_ModeInfo,MUIA_DispIDinfo_ID,INVALID_ID);
  1547.             set(data->TX_Info,MUIA_Text_Contents,GetStr(MSG_TEXT_UNKNOWNMODE));
  1548.             set(data->GR_Size,MUIA_Disabled,TRUE);
  1549.         }
  1550.     }
  1551.     /*
  1552.     else
  1553.     {
  1554.         set(data->TX_Info,MUIA_Text_Contents,GetStr(MSG_TEXT_FOREIGNSCREEN));
  1555.     }
  1556.     */
  1557.  
  1558.     data->update = FALSE;
  1559.     return(0);
  1560. }
  1561.  
  1562.  
  1563. SAVEDS ASM ULONG EditPanel_Dispatcher(REG(a0) struct IClass *cl,REG(a2) Object *obj,REG(a1) Msg msg)
  1564. {
  1565.     switch (msg->MethodID)
  1566.     {
  1567.         case OM_NEW                      : return(EditPanel_New              (cl,obj,(APTR)msg));
  1568.         case OM_DISPOSE                  : return(EditPanel_Dispose          (cl,obj,(APTR)msg));
  1569.  
  1570.         case MUIM_ContextMenuChoice      : return(EditPanel_ContextMenuChoice(cl,obj,(APTR)msg));
  1571.  
  1572.         case MUIM_EditPanel_SetScreen    : return(EditPanel_SetScreen        (cl,obj,(APTR)msg));
  1573.         case MUIM_EditPanel_GetScreen    : return(EditPanel_GetScreen        (cl,obj,(APTR)msg));
  1574.         case MUIM_EditPanel_Update       : return(EditPanel_Update           (cl,obj,(APTR)msg));
  1575.         /*
  1576.         case MUIM_EditPanel_ToggleForeign: return(EditPanel_ToggleForeign    (cl,obj,(APTR)msg));
  1577.         */
  1578.     }
  1579.     return(DoSuperMethodA(cl,obj,msg));
  1580. }
  1581.  
  1582.  
  1583.  
  1584. /****************************************************************************/
  1585. /* EditWindow class                                                         */
  1586. /****************************************************************************/
  1587.  
  1588. struct EditWindow_Data
  1589. {
  1590.     Object *panel;
  1591.     char wtitle[PSD_MAXLEN_TITLE+20];
  1592. };
  1593.  
  1594. ULONG EditWindow_New(struct IClass *cl,Object *obj,struct opSet *msg)
  1595. {
  1596.     struct EditWindow_Data *data;
  1597.     Object *ok;
  1598.     Object *cancel;
  1599.     Object *panel;
  1600.     Object *originator;
  1601.     /*Object *strip;*/
  1602.  
  1603.     if (obj = (Object *)DoSuperNew(cl,obj,
  1604.         /*MUIA_Window_Menustrip, strip = MUI_MakeObject(MUIO_MenustripNM,EditMenu,0),*/
  1605.         WindowContents, VGroup,
  1606.             Child, panel = NewObject(CL_EditPanel->mcc_Class,NULL,TAG_DONE),
  1607.             Child, HGroup, MUIA_Group_SameSize, TRUE,
  1608.                 Child, ok = MakeButton(MSG_BUTTON_OK),
  1609.                 Child, HSpace(0),
  1610.                 Child, HSpace(0),
  1611.                 Child, HSpace(0),
  1612.                 Child, cancel = MakeButton(MSG_BUTTON_CANCEL),
  1613.                 End,
  1614.             End,
  1615.         TAG_MORE,msg->ops_AttrList))
  1616.     {
  1617.         data = INST_DATA(cl,obj);
  1618.  
  1619.         data->panel = panel;
  1620.  
  1621.         strcpy(data->wtitle,GetStr(MSG_TITLE_PUBSCREENWINDOW));
  1622.         strcat(data->wtitle," ");
  1623.         strcat(data->wtitle,(char *)GetTagData(MUIA_EditWindow_Title,(ULONG)"",msg->ops_AttrList));
  1624.  
  1625.         set(obj,MUIA_Window_Title,data->wtitle);
  1626.         set(obj,MUIA_Window_ID   ,MAKE_ID('E','D','I','T'));
  1627.  
  1628.         originator = (Object *)GetTagData(MUIA_EditWindow_Originator,0,msg->ops_AttrList);
  1629.  
  1630.         DoMethod(obj   ,MUIM_Notify,MUIA_Window_CloseRequest,TRUE ,MUIV_Notify_Application,6,MUIM_Application_PushMethod,originator,3,MUIM_ScreenPanel_Finish,obj,FALSE);
  1631.         DoMethod(cancel,MUIM_Notify,MUIA_Pressed            ,FALSE,MUIV_Notify_Application,6,MUIM_Application_PushMethod,originator,3,MUIM_ScreenPanel_Finish,obj,FALSE);
  1632.         DoMethod(ok    ,MUIM_Notify,MUIA_Pressed            ,FALSE,MUIV_Notify_Application,6,MUIM_Application_PushMethod,originator,3,MUIM_ScreenPanel_Finish,obj,TRUE );
  1633.  
  1634.         /*
  1635.         DoMethod((Object *)DoMethod(strip,MUIM_FindUData,MEN_2COL),MUIM_Notify,MUIA_Menuitem_Trigger,MUIV_EveryTime,panel,2,MUIM_EditPanel_DefColors,0);
  1636.         DoMethod((Object *)DoMethod(strip,MUIM_FindUData,MEN_4COL),MUIM_Notify,MUIA_Menuitem_Trigger,MUIV_EveryTime,panel,2,MUIM_EditPanel_DefColors,1);
  1637.         DoMethod((Object *)DoMethod(strip,MUIM_FindUData,MEN_8COL),MUIM_Notify,MUIA_Menuitem_Trigger,MUIV_EveryTime,panel,2,MUIM_EditPanel_DefColors,2);
  1638.         */
  1639.  
  1640.         set(ok    ,MUIA_ShortHelp,GetStr(MSG_HELP_EDITOK    ));
  1641.         set(cancel,MUIA_ShortHelp,GetStr(MSG_HELP_EDITCANCEL));
  1642.  
  1643.         return((ULONG)obj);
  1644.     }
  1645.     return(0);
  1646. }
  1647.  
  1648. SAVEDS ASM ULONG EditWindow_Dispatcher(REG(a0) struct IClass *cl,REG(a2) Object *obj,REG(a1) Msg msg)
  1649. {
  1650.     switch (msg->MethodID)
  1651.     {
  1652.         case OM_NEW: return(EditWindow_New(cl,obj,(APTR)msg));
  1653.  
  1654.         /*
  1655.         **    The next methods actually don't belong to the
  1656.         ** edit window class. We just forward them here to
  1657.         ** allow treating an edit window much like an edit
  1658.         ** panel from outside.
  1659.         */
  1660.  
  1661.         case MUIM_EditPanel_SetScreen:
  1662.         case MUIM_EditPanel_GetScreen:
  1663.         {
  1664.             struct EditWindow_Data *data = INST_DATA(cl,obj);
  1665.             return(DoMethodA(data->panel,msg));
  1666.         }
  1667.     }
  1668.     return(DoSuperMethodA(cl,obj,msg));
  1669. }
  1670.  
  1671.  
  1672.  
  1673. /****************************************************************************/
  1674. /* ScreenList class                                                         */
  1675. /****************************************************************************/
  1676.  
  1677. #define USE_PSI_SCREENON_HEADER
  1678. #define USE_PSI_SCREENON_BODY
  1679. #define USE_PSI_SCREENON_COLORS
  1680. #include "psi_screenon.bh"
  1681.  
  1682. /*
  1683. #define USE_PSI_SCREENOF_BODY
  1684. #include "psi_screenof.bh"
  1685. */
  1686.  
  1687. #define USE_PSI_SCREENCN_BODY
  1688. #include "psi_screencn.bh"
  1689.  
  1690. /*
  1691. #define USE_PSI_SCREENCF_BODY
  1692. #include "psi_screencf.bh"
  1693. */
  1694.  
  1695.  
  1696.  
  1697. struct ScreenList_Data
  1698. {
  1699.     Object *list;
  1700.     Object *onormal[2];
  1701.     /*
  1702.     Object *oforeign[2];
  1703.     */
  1704.     APTR inormal[2];
  1705.     /*
  1706.     APTR iforeign[2];
  1707.     */
  1708.     struct Hook DisplayHook;
  1709. };
  1710.  
  1711. SAVEDS ASM APTR ScreenList_ConstructFunc(REG(a1) struct MUI_PubScreenDesc *src)
  1712. {
  1713.     struct MUI_PubScreenDesc *desc;
  1714.  
  1715.     if (desc = MUIS_AllocPubScreenDesc(src))
  1716.     {
  1717.         desc->Changed  = FALSE;
  1718.         desc->UserData = NULL;
  1719.     }
  1720.     return(desc);
  1721. }
  1722.  
  1723. SAVEDS ASM VOID ScreenList_DestructFunc(REG(a1) struct MUI_PubScreenDesc *desc)
  1724. {
  1725.     MUIS_FreePubScreenDesc(desc);
  1726. }
  1727.  
  1728. SAVEDS ASM LONG ScreenList_CompareFunc(REG(a1) struct MUI_PubScreenDesc *d1,REG(a2) struct MUI_PubScreenDesc *d2)
  1729. {
  1730.     /*
  1731.     if (d1->Foreign && !d2->Foreign)
  1732.         return(-1);
  1733.  
  1734.     if (d2->Foreign && !d1->Foreign)
  1735.         return(1);
  1736.     */
  1737.  
  1738.     if (!strcmp(d1->Name,PSD_INITIAL_NAME))
  1739.         return(strcmp(d2->Name,PSD_INITIAL_NAME) ? 1 : 0);
  1740.     else if (!strcmp(d2->Name,PSD_INITIAL_NAME))
  1741.         return(-1);
  1742.     else
  1743.         return(stricmp(d1->Name,d2->Name));
  1744. }
  1745.  
  1746. SAVEDS ASM LONG ScreenList_DisplayFunc(REG(a0) struct Hook *hook,REG(a2) char **array,REG(a1) struct MUI_PubScreenDesc *desc)
  1747. {
  1748.     struct ScreenList_Data *data = (APTR)hook->h_Data;
  1749.  
  1750.     *array++ = "";
  1751.  
  1752.     if (!desc)
  1753.     {
  1754.         static char buf1[30],buf2[30];
  1755.         strcpy(buf1,"\33b\33u");
  1756.         strcpy(buf2,"\33b\33u");
  1757.         strcat(buf1,GetStr(MSG_LIST_SCREENNAME));
  1758.         strcat(buf2,GetStr(MSG_LIST_SCREENMODE));
  1759.         *array++ = "";
  1760.         *array++ = buf1;
  1761.         *array   = buf2;
  1762.     }
  1763.     else
  1764.     {
  1765.         static struct NameInfo ni;
  1766.         static char buf1[PSD_MAXLEN_NAME+2];
  1767.         static char buf2[50];
  1768.  
  1769.         strcpy(buf1,desc->UserData ? "\33b" : desc->Changed ? "\33u" : "");
  1770.         strcat(buf1,desc->Name);
  1771.  
  1772.         /*
  1773.         if (desc->Foreign)
  1774.         {
  1775.             strcpy(ni.Name,GetStr(MSG_LIST_FOREIGNSCREEN));
  1776.             sprintf(buf2,"\33O[%08lx]",data->iforeign[TestPubScreen(desc->Name) ? 1 : 0]);
  1777.         }
  1778.         else
  1779.         */
  1780.         {
  1781.             if (!GetDisplayInfoData(0,(UBYTE *)&ni,sizeof(ni),DTAG_NAME,desc->DisplayID))
  1782.                 strcpy(ni.Name,GetStr(MSG_LIST_UNKNOWNMODE));
  1783.  
  1784.             sprintf(buf2,"\33O[%08lx]",data->inormal[TestPubScreen(desc->Name) ? 1 : 0]);
  1785.         }
  1786.  
  1787.         *array++ = buf2;
  1788.         *array++ = buf1;
  1789.         *array   = ni.Name;
  1790.     }
  1791.  
  1792.     return(0);
  1793. }
  1794.  
  1795.  
  1796. ULONG ScreenList_Load(struct IClass *cl,Object *obj,struct MUIP_ScreenList_Load *msg)
  1797. {
  1798.     ULONG result = FALSE;
  1799.     struct MUI_PubScreenDesc *desc;
  1800.     APTR pfh;
  1801.  
  1802.     if (pfh = MUIS_OpenPubFile(msg->name,MODE_OLDFILE))
  1803.     {
  1804.         result = TRUE;
  1805.  
  1806.         if (msg->clear)
  1807.             DoMethod(obj,MUIM_List_Clear);
  1808.  
  1809.         set(obj,MUIA_List_Quiet,TRUE);
  1810.  
  1811.         while (desc = MUIS_ReadPubFile(pfh))
  1812.         {
  1813.             DoMethod(obj,MUIM_List_InsertSingle,desc,MUIV_List_Insert_Sorted);
  1814.         }
  1815.  
  1816.         set(obj,MUIA_List_Quiet,FALSE);
  1817.  
  1818.         MUIS_ClosePubFile(pfh);
  1819.     }
  1820.     return(result);
  1821. }
  1822.  
  1823.  
  1824. ULONG ScreenList_Save(struct IClass *cl,Object *obj,struct MUIP_ScreenList_Save *msg)
  1825. {
  1826.     ULONG result = FALSE;
  1827.     struct MUI_PubScreenDesc *desc;
  1828.     APTR pfh;
  1829.     int i;
  1830.  
  1831.     DoMethod(obj,MUIM_List_Sort);
  1832.  
  1833.     if (pfh = MUIS_OpenPubFile(msg->name,MODE_NEWFILE))
  1834.     {
  1835.         result = TRUE;
  1836.  
  1837.         for (i=0;result;i++)
  1838.         {
  1839.             DoMethod(obj,MUIM_List_GetEntry,i,&desc);
  1840.             if (!desc) break;
  1841.  
  1842.             desc->Changed  = FALSE;
  1843.             desc->UserData = NULL;
  1844.  
  1845.             if (!MUIS_WritePubFile(pfh,desc))
  1846.                 result = FALSE;
  1847.         }
  1848.         MUIS_ClosePubFile(pfh);
  1849.     }
  1850.     return(result);
  1851. }
  1852.  
  1853.  
  1854. ULONG ScreenList_Find(struct IClass *cl,Object *obj,struct MUIP_ScreenList_Find *msg)
  1855. {
  1856.     int i;
  1857.     struct MUI_PubScreenDesc *desc;
  1858.  
  1859.     *(msg->desc) = NULL;
  1860.  
  1861.     for (i=0;;i++)
  1862.     {
  1863.         DoMethod(obj,MUIM_List_GetEntry,i,&desc);
  1864.         if (!desc) break;
  1865.         if (!stricmp(desc->Name,msg->name))
  1866.         {
  1867.             *(msg->desc) = desc;
  1868.             set(obj,MUIA_List_Active,i);
  1869.             break;
  1870.         }
  1871.     }
  1872.     return(0);
  1873. }
  1874.  
  1875.  
  1876. static Object *makescreenimage(UBYTE *body)
  1877. {
  1878.     Object *obj = BodychunkObject,
  1879.         MUIA_FixWidth             , PSI_SCREENON_WIDTH ,
  1880.         MUIA_FixHeight            , PSI_SCREENON_HEIGHT,
  1881.         MUIA_Bitmap_Width         , PSI_SCREENON_WIDTH ,
  1882.         MUIA_Bitmap_Height        , PSI_SCREENON_HEIGHT,
  1883.         MUIA_Bodychunk_Depth      , PSI_SCREENON_DEPTH ,
  1884.         MUIA_Bodychunk_Body       , (UBYTE *)body,
  1885.         MUIA_Bodychunk_Compression, PSI_SCREENON_COMPRESSION,
  1886.         MUIA_Bodychunk_Masking    , PSI_SCREENON_MASKING,
  1887.         MUIA_Bitmap_SourceColors  , (ULONG *)psi_screenon_colors,
  1888.         MUIA_Bitmap_Transparent   , 0,
  1889.         End;
  1890.  
  1891.     return(obj);
  1892. }
  1893.  
  1894.  
  1895. ULONG ScreenList_Setup(struct IClass *cl,Object *obj,Msg msg)
  1896. {
  1897.     struct ScreenList_Data *data = INST_DATA(cl,obj);
  1898.  
  1899.     if (!DoSuperMethodA(cl,obj,msg))
  1900.         return(FALSE);
  1901.  
  1902.     data->onormal[0]  = makescreenimage((UBYTE *)psi_screencn_body);
  1903.     data->onormal[1]  = makescreenimage((UBYTE *)psi_screenon_body);
  1904.     /*
  1905.     data->oforeign[0] = makescreenimage((UBYTE *)psi_screencf_body);
  1906.     data->oforeign[1] = makescreenimage((UBYTE *)psi_screenof_body);
  1907.     */
  1908.  
  1909.     data->inormal[0]  = (APTR)DoMethod(obj,MUIM_List_CreateImage,data->onormal[0] ,0);
  1910.     data->inormal[1]  = (APTR)DoMethod(obj,MUIM_List_CreateImage,data->onormal[1] ,0);
  1911.     /*
  1912.     data->iforeign[0] = (APTR)DoMethod(obj,MUIM_List_CreateImage,data->oforeign[0],0);
  1913.     data->iforeign[1] = (APTR)DoMethod(obj,MUIM_List_CreateImage,data->oforeign[1],0);
  1914.     */
  1915.  
  1916.     MUI_RequestIDCMP(obj,IDCMP_MOUSEBUTTONS|IDCMP_RAWKEY);
  1917.  
  1918.     return(TRUE);
  1919. }
  1920.  
  1921.  
  1922. ULONG ScreenList_Cleanup(struct IClass *cl,Object *obj,Msg msg)
  1923. {
  1924.     struct ScreenList_Data *data = INST_DATA(cl,obj);
  1925.  
  1926.     DoMethod(obj,MUIM_List_DeleteImage,data->inormal[0] );
  1927.     DoMethod(obj,MUIM_List_DeleteImage,data->inormal[1] );
  1928.     /*
  1929.     DoMethod(obj,MUIM_List_DeleteImage,data->iforeign[0]);
  1930.     DoMethod(obj,MUIM_List_DeleteImage,data->iforeign[1]);
  1931.     */
  1932.  
  1933.     if (data->onormal[0] ) MUI_DisposeObject(data->onormal[0] );
  1934.     if (data->onormal[1] ) MUI_DisposeObject(data->onormal[1] );
  1935.     /*
  1936.     if (data->oforeign[0]) MUI_DisposeObject(data->oforeign[0]);
  1937.     if (data->oforeign[1]) MUI_DisposeObject(data->oforeign[1]);
  1938.     */
  1939.  
  1940.     MUI_RejectIDCMP(obj,IDCMP_MOUSEBUTTONS|IDCMP_RAWKEY);
  1941.  
  1942.     return(DoSuperMethodA(cl,obj,msg));
  1943. }
  1944.  
  1945.  
  1946. ULONG ScreenList_New(struct IClass *cl,Object *obj,struct opSet *msg)
  1947. {
  1948.     static const struct Hook ScreenList_ConstructHook = { { 0,0 }, (VOID *)ScreenList_ConstructFunc, NULL, NULL };
  1949.     static const struct Hook ScreenList_DestructHook  = { { 0,0 }, (VOID *)ScreenList_DestructFunc , NULL, NULL };
  1950.     static const struct Hook ScreenList_CompareHook   = { { 0,0 }, (VOID *)ScreenList_CompareFunc  , NULL, NULL };
  1951.  
  1952.     obj=(Object *)DoSuperNew(cl,obj,
  1953.         MUIA_List_ConstructHook, &ScreenList_ConstructHook,
  1954.         MUIA_List_DestructHook , &ScreenList_DestructHook,
  1955.         MUIA_List_CompareHook  , &ScreenList_CompareHook,
  1956.         MUIA_List_Format       , "DELTA=2,,,",
  1957.         MUIA_List_Title        , TRUE,
  1958.         MUIA_List_MinLineHeight, 14,
  1959.         TAG_MORE,msg->ops_AttrList);
  1960.  
  1961.     if (obj)
  1962.     {
  1963.         struct ScreenList_Data *data = INST_DATA(cl,obj);
  1964.  
  1965.         data->DisplayHook.h_Entry = (VOID *)ScreenList_DisplayFunc;
  1966.         data->DisplayHook.h_Data  = (APTR)data;
  1967.  
  1968.         set(obj,MUIA_List_DisplayHook,&data->DisplayHook);
  1969.     }
  1970.  
  1971.     return((ULONG)obj);
  1972. }
  1973.  
  1974. SAVEDS ASM ULONG ScreenList_Dispatcher(REG(a0) struct IClass *cl,REG(a2) Object *obj,REG(a1) Msg msg)
  1975. {
  1976.     switch (msg->MethodID)
  1977.     {
  1978.         case OM_NEW              : return(ScreenList_New    (cl,obj,(APTR)msg));
  1979.         case MUIM_Setup          : return(ScreenList_Setup  (cl,obj,(APTR)msg));
  1980.         case MUIM_Cleanup        : return(ScreenList_Cleanup(cl,obj,(APTR)msg));
  1981.         case MUIM_ScreenList_Save: return(ScreenList_Save   (cl,obj,(APTR)msg));
  1982.         case MUIM_ScreenList_Load: return(ScreenList_Load   (cl,obj,(APTR)msg));
  1983.         case MUIM_ScreenList_Find: return(ScreenList_Find   (cl,obj,(APTR)msg));
  1984.     }
  1985.     return(DoSuperMethodA(cl,obj,msg));
  1986. }
  1987.  
  1988.  
  1989.  
  1990. /****************************************************************************/
  1991. /* ScreenPanel class                                                        */
  1992. /****************************************************************************/
  1993.  
  1994. struct ScreenPanel_Data
  1995. {
  1996.     Object *LV_Screens;
  1997.     Object *BT_Create;
  1998.     Object *BT_Copy;
  1999.     Object *BT_Delete;
  2000.     Object *BT_Edit;
  2001.     Object *BT_Open;
  2002.     Object *BT_Close;
  2003.     Object *BT_Jump;
  2004.     #ifdef MYDEBUG
  2005.     Object *BT_Foo;
  2006.     #endif
  2007. };
  2008.  
  2009. ULONG ScreenPanel_Finish(struct IClass *cl,Object *obj,struct MUIP_ScreenPanel_Finish *msg)
  2010. {
  2011.     struct ScreenPanel_Data *data = INST_DATA(cl,obj);
  2012.     struct MUI_PubScreenDesc *desc;
  2013.     int i;
  2014.     Object *win = msg->win;
  2015.     BOOL ok = msg->ok;
  2016.  
  2017.     for (i=0;;i++)
  2018.     {
  2019.         DoMethod(data->LV_Screens,MUIM_List_GetEntry,i,&desc);
  2020.         if (!desc) return(0); /* should never happen */
  2021.         if (desc->UserData==win) break;
  2022.     }
  2023.  
  2024.     desc->UserData = NULL;
  2025.  
  2026.     if (ok)
  2027.     {
  2028.         DoMethod(win,MUIM_EditPanel_GetScreen,desc);
  2029.         desc->Changed = TRUE;
  2030.     }
  2031.     DoMethod(data->LV_Screens,MUIM_List_Redraw,i);
  2032.     DoMethod(obj,MUIM_ScreenPanel_SetStates);
  2033.  
  2034.     set(win,MUIA_Window_Open,FALSE);
  2035.     DoMethod((Object *)xget(obj,MUIA_ApplicationObject),OM_REMMEMBER,win);
  2036.     MUI_DisposeObject(win);
  2037.  
  2038.     return(0);
  2039. }
  2040.  
  2041. ULONG ScreenPanel_Edit(struct IClass *cl,Object *obj,Msg msg)
  2042. {
  2043.     struct ScreenPanel_Data *data = INST_DATA(cl,obj);
  2044.     struct MUI_PubScreenDesc *desc;
  2045.  
  2046.     DoMethod(data->LV_Screens,MUIM_List_GetEntry,MUIV_List_GetEntry_Active,&desc);
  2047.  
  2048.     if (desc)
  2049.     {
  2050.         set((Object *)xget(obj,MUIA_ApplicationObject),MUIA_Application_Sleep,TRUE);
  2051.  
  2052.         if (!desc->UserData)
  2053.         {
  2054.             if (desc->UserData = (APTR)NewObject(CL_EditWindow->mcc_Class,NULL,
  2055.                 MUIA_Window_Width , MUIV_Window_Width_MinMax(0),
  2056.                 MUIA_Window_Height, MUIV_Window_Height_MinMax(0),
  2057.                 MUIA_EditWindow_Title, desc->Name,
  2058.                 MUIA_EditWindow_Originator, obj,
  2059.                 TAG_DONE))
  2060.             {
  2061.                 DoMethod((Object *)xget(obj,MUIA_ApplicationObject),OM_ADDMEMBER,desc->UserData);
  2062.                 DoMethod(desc->UserData,MUIM_EditPanel_SetScreen,desc);
  2063.                 DoMethod(data->LV_Screens,MUIM_List_Redraw,MUIV_List_Redraw_Active);
  2064.             }
  2065.         }
  2066.  
  2067.         if (desc->UserData)
  2068.             set(desc->UserData,MUIA_Window_Open,TRUE);
  2069.         else
  2070.             DisplayBeep(0);
  2071.  
  2072.         set((Object *)xget(obj,MUIA_ApplicationObject),MUIA_Application_Sleep,FALSE);
  2073.     }
  2074.     return(0);
  2075. }
  2076.  
  2077. ULONG ScreenPanel_Delete(struct IClass *cl,Object *obj,Msg msg)
  2078. {
  2079.     struct ScreenPanel_Data *data = INST_DATA(cl,obj);
  2080.     struct MUI_PubScreenDesc *desc;
  2081.  
  2082.     DoMethod(data->LV_Screens,MUIM_List_GetEntry,MUIV_List_GetEntry_Active,&desc);
  2083.     if (desc)
  2084.     {
  2085.         if (!desc->UserData)
  2086.         {
  2087.             MUIS_ClosePubScreen(desc->Name);
  2088.             DoMethod(data->LV_Screens,MUIM_List_Remove,MUIV_List_Remove_Active);
  2089.         }
  2090.         else
  2091.             DisplayBeep(0);
  2092.     }
  2093.     return(0);
  2094. }
  2095.  
  2096. ULONG ScreenPanel_Create(struct IClass *cl,Object *obj,Msg msg)
  2097. {
  2098.     struct ScreenPanel_Data *data = INST_DATA(cl,obj);
  2099.     DoMethod(data->LV_Screens,MUIM_List_InsertSingle,NULL,MUIV_List_Insert_Bottom);
  2100.     set(data->LV_Screens,MUIA_List_Active,MUIV_List_Active_Bottom);
  2101.     return(0);
  2102. }
  2103.  
  2104. ULONG ScreenPanel_Copy(struct IClass *cl,Object *obj,Msg msg)
  2105. {
  2106.     struct ScreenPanel_Data *data = INST_DATA(cl,obj);
  2107.     struct MUI_PubScreenDesc *new,*src;
  2108.     DoMethod(data->LV_Screens,MUIM_List_GetEntry,MUIV_List_GetEntry_Active,&src);
  2109.     if (new = MUIS_AllocPubScreenDesc(src))
  2110.     {
  2111.         char namebuf[PSD_MAXLEN_NAME];
  2112.         strcpy(namebuf,new->Name);
  2113.         strcpy(new->Name,">");
  2114.         stccpy(new->Name+1,namebuf,PSD_MAXLEN_NAME-1);
  2115.         DoMethod(data->LV_Screens,MUIM_List_InsertSingle,new,MUIV_List_Insert_Bottom);
  2116.         set(data->LV_Screens,MUIA_List_Active,MUIV_List_Active_Bottom);
  2117.         MUIS_FreePubScreenDesc(new);
  2118.     }
  2119.     else
  2120.         DisplayBeep(0);
  2121.     return(0);
  2122. }
  2123.  
  2124. ULONG ScreenPanel_SetStates(struct IClass *cl,Object *obj,Msg msg)
  2125. {
  2126.     struct ScreenPanel_Data *data = INST_DATA(cl,obj);
  2127.     struct MUI_PubScreenDesc *desc;
  2128.     DoMethod(data->LV_Screens,MUIM_List_GetEntry,MUIV_List_GetEntry_Active,&desc);
  2129.     if (desc)
  2130.     {
  2131.         /*
  2132.         if (desc->Foreign)
  2133.         {
  2134.             set(data->BT_Copy  ,MUIA_Disabled,FALSE);
  2135.             set(data->BT_Delete,MUIA_Disabled,FALSE);
  2136.             set(data->BT_Edit  ,MUIA_Disabled,FALSE);
  2137.             set(data->BT_Open  ,MUIA_Disabled,TRUE );
  2138.             set(data->BT_Close ,MUIA_Disabled,TRUE );
  2139.             set(data->BT_Jump  ,MUIA_Disabled,FALSE);
  2140.         }
  2141.         else
  2142.         */
  2143.         {
  2144.             BOOL opened = TestPubScreen(desc->Name);
  2145.  
  2146.             set(data->BT_Copy  ,MUIA_Disabled,FALSE);
  2147.             set(data->BT_Delete,MUIA_Disabled,FALSE);
  2148.             set(data->BT_Edit  ,MUIA_Disabled,FALSE);
  2149.             set(data->BT_Open  ,MUIA_Disabled, opened);
  2150.             set(data->BT_Close ,MUIA_Disabled,!opened);
  2151.             set(data->BT_Jump  ,MUIA_Disabled,FALSE);
  2152.         }
  2153.     }
  2154.     else
  2155.     {
  2156.         set(data->BT_Copy  ,MUIA_Disabled,TRUE);
  2157.         set(data->BT_Delete,MUIA_Disabled,TRUE);
  2158.         set(data->BT_Edit  ,MUIA_Disabled,TRUE);
  2159.         set(data->BT_Open  ,MUIA_Disabled,TRUE);
  2160.         set(data->BT_Close ,MUIA_Disabled,TRUE);
  2161.         set(data->BT_Jump  ,MUIA_Disabled,TRUE);
  2162.     }
  2163.     return(0);
  2164. }
  2165.  
  2166. ULONG ScreenPanel_Close(struct IClass *cl,Object *obj,Msg msg)
  2167. {
  2168.     struct ScreenPanel_Data *data = INST_DATA(cl,obj);
  2169.     struct MUI_PubScreenDesc *desc;
  2170.     DoMethod(data->LV_Screens,MUIM_List_GetEntry,MUIV_List_GetEntry_Active,&desc);
  2171.     if (!desc || !MUIS_ClosePubScreen(desc->Name))
  2172.         DisplayBeep(0);
  2173.     return(0);
  2174. }
  2175.  
  2176. ULONG ScreenPanel_Open(struct IClass *cl,Object *obj,Msg msg)
  2177. {
  2178.     struct ScreenPanel_Data *data = INST_DATA(cl,obj);
  2179.     struct MUI_PubScreenDesc *desc;
  2180.     DoMethod(data->LV_Screens,MUIM_List_GetEntry,MUIV_List_GetEntry_Active,&desc);
  2181.    if (desc)
  2182.     {
  2183.         if (desc->Changed)
  2184.         {
  2185.             /* !!! */
  2186.         }
  2187.         if (!MUIS_OpenPubScreen(desc))
  2188.             DisplayBeep(0);
  2189.     }
  2190.     else
  2191.         DisplayBeep(0);
  2192.     return(0);
  2193. }
  2194.  
  2195. ULONG ScreenPanel_Jump(struct IClass *cl,Object *obj,Msg msg)
  2196. {
  2197.     struct ScreenPanel_Data *data = INST_DATA(cl,obj);
  2198.     struct MUI_PubScreenDesc *desc;
  2199.     DoMethod(data->LV_Screens,MUIM_List_GetEntry,MUIV_List_GetEntry_Active,&desc);
  2200.     if (desc)
  2201.     {
  2202.         if (desc->Changed)
  2203.         {
  2204.             /* !!! */
  2205.         }
  2206.         DoMethod((Object *)xget(obj,MUIA_ApplicationObject),MUIM_Application_SetConfigItem,MUICFG_PublicScreen,desc->Name);
  2207.     }
  2208.     else
  2209.         DisplayBeep(0);
  2210.  
  2211.     return(0);
  2212. }
  2213.  
  2214. ULONG ScreenPanel_Update(struct IClass *cl,Object *obj,Msg msg)
  2215. {
  2216.     struct ScreenPanel_Data *data = INST_DATA(cl,obj);
  2217.     DoMethod(data->LV_Screens,MUIM_List_Redraw,MUIV_List_Redraw_All);
  2218.     DoMethod(obj,MUIM_ScreenPanel_SetStates);
  2219.     return(0);
  2220. }
  2221.  
  2222. ULONG ScreenPanel_New(struct IClass *cl,Object *obj,struct opSet *msg)
  2223. {
  2224.     struct ScreenPanel_Data tmp = {0};
  2225.  
  2226.     obj = (Object *)DoSuperNew(cl,obj,
  2227.         MUIA_Group_Horiz, FALSE,
  2228.         MUIA_Group_VertSpacing, 0,
  2229.         Child, tmp.LV_Screens = ListviewObject,
  2230.             MUIA_CycleChain, 1,
  2231.             MUIA_Listview_List, NewObject(CL_ScreenList->mcc_Class,NULL,InputListFrame,MUIA_List_AutoVisible,TRUE,TAG_DONE),
  2232.             End,
  2233.         Child, ColGroup(4), GroupSpacing(0), MUIA_Group_SameSize, TRUE,
  2234.             Child, tmp.BT_Create = MakeButton(MSG_BUTTON_NEW),
  2235.             Child, tmp.BT_Copy   = MakeButton(MSG_BUTTON_COPY),
  2236.             Child, tmp.BT_Delete = MakeButton(MSG_BUTTON_DELETE),
  2237.             Child, tmp.BT_Edit   = MakeButton(MSG_BUTTON_EDIT),
  2238.             Child, tmp.BT_Open   = MakeButton(MSG_BUTTON_OPEN),
  2239.             Child, tmp.BT_Close  = MakeButton(MSG_BUTTON_CLOSE),
  2240.             Child, tmp.BT_Jump   = MakeButton(MSG_BUTTON_JUMP),
  2241.             #ifdef MYDEBUG
  2242.             Child, tmp.BT_Foo    = SimpleButton("Foo"),
  2243.             #else
  2244.             Child, HVSpace,
  2245.             #endif
  2246.             End,
  2247.         TAG_DONE);
  2248.  
  2249.     if (obj)
  2250.     {
  2251.         struct ScreenPanel_Data *data = INST_DATA(cl,obj);
  2252.  
  2253.         *data = tmp;
  2254.  
  2255.         DoMethod(tmp.BT_Delete ,MUIM_Notify,MUIA_Pressed,FALSE,obj,1,MUIM_ScreenPanel_Delete);
  2256.         DoMethod(tmp.BT_Create ,MUIM_Notify,MUIA_Pressed,FALSE,obj,1,MUIM_ScreenPanel_Create);
  2257.         DoMethod(tmp.BT_Copy   ,MUIM_Notify,MUIA_Pressed,FALSE,obj,1,MUIM_ScreenPanel_Copy  );
  2258.         DoMethod(tmp.BT_Edit   ,MUIM_Notify,MUIA_Pressed,FALSE,obj,1,MUIM_ScreenPanel_Edit  );
  2259.         DoMethod(tmp.BT_Open   ,MUIM_Notify,MUIA_Pressed,FALSE,obj,1,MUIM_ScreenPanel_Open  );
  2260.         DoMethod(tmp.BT_Close  ,MUIM_Notify,MUIA_Pressed,FALSE,obj,1,MUIM_ScreenPanel_Close );
  2261.         DoMethod(tmp.BT_Jump   ,MUIM_Notify,MUIA_Pressed,FALSE,obj,1,MUIM_ScreenPanel_Jump  );
  2262.         #ifdef MYDEBUG
  2263.         DoMethod(tmp.BT_Foo    ,MUIM_Notify,MUIA_Pressed,FALSE,obj,1,MUIM_ScreenPanel_Foo   );
  2264.         #endif
  2265.         DoMethod(tmp.LV_Screens,MUIM_Notify,MUIA_Listview_DoubleClick,TRUE,obj,1,MUIM_ScreenPanel_Edit);
  2266.         DoMethod(tmp.LV_Screens,MUIM_Notify,MUIA_List_Active,MUIV_EveryTime,obj,1,MUIM_ScreenPanel_SetStates);
  2267.  
  2268.         set(tmp.BT_Delete ,MUIA_ShortHelp,GetStr(MSG_HELP_DELETESCREEN));
  2269.         set(tmp.BT_Create ,MUIA_ShortHelp,GetStr(MSG_HELP_NEWSCREEN   ));
  2270.         set(tmp.BT_Copy   ,MUIA_ShortHelp,GetStr(MSG_HELP_COPYSCREEN  ));
  2271.         set(tmp.BT_Edit   ,MUIA_ShortHelp,GetStr(MSG_HELP_EDITSCREEN  ));
  2272.         set(tmp.BT_Open   ,MUIA_ShortHelp,GetStr(MSG_HELP_OPENSCREEN  ));
  2273.         set(tmp.BT_Close  ,MUIA_ShortHelp,GetStr(MSG_HELP_CLOSESCREEN ));
  2274.         set(tmp.BT_Jump   ,MUIA_ShortHelp,GetStr(MSG_HELP_JUMPSCREEN  ));
  2275.         set(tmp.LV_Screens,MUIA_ShortHelp,GetStr(MSG_HELP_SCREENLIST  ));
  2276.  
  2277.         DoMethod(obj,MUIM_ScreenPanel_SetStates);
  2278.     }
  2279.     return((ULONG)obj);
  2280. }
  2281.  
  2282. ULONG ScreenPanel_Dispose(struct IClass *cl,Object *obj,Msg msg)
  2283. {
  2284.     DoMethod(obj,MUIM_ScreenPanel_CloseWindows);
  2285.     return(DoSuperMethodA(cl,obj,msg));
  2286. }
  2287.  
  2288. ULONG ScreenPanel_CloseWindows(struct IClass *cl,Object *obj,Msg msg)
  2289. {
  2290.     struct ScreenPanel_Data *data = INST_DATA(cl,obj);
  2291.     struct MUI_PubScreenDesc *desc;
  2292.     int i;
  2293.     for (i=0;;i++)
  2294.     {
  2295.         DoMethod(data->LV_Screens,MUIM_List_GetEntry,i,&desc);
  2296.         if (!desc) break;
  2297.         if (desc->UserData) DoMethod(obj,MUIM_ScreenPanel_Finish,desc->UserData,FALSE);
  2298.     }
  2299.     return(0);
  2300. }
  2301.  
  2302. #ifdef MYDEBUG
  2303.  
  2304. BOOL SavePubScreen(struct MUI_PubScreenDesc *desc)
  2305. {
  2306.     BPTR file;
  2307.     char filename[PSD_MAXLEN_NAME+16];
  2308.     int p;
  2309.     BOOL rc = FALSE;
  2310.  
  2311.     strcpy(filename,"mui:Screens");
  2312.     AddPart(filename,desc->Name,sizeof(filename));
  2313.     strcat(filename,".mps");
  2314.  
  2315.     if (file = Open(filename,MODE_NEWFILE))
  2316.     {
  2317.         FPrintf(file,"T=\"%s\"\n",desc->Title       );
  2318.         FPrintf(file,"F=\"%s\"\n",desc->Font        );
  2319.         FPrintf(file,"B=\"%s\"\n",desc->Background  );
  2320.         FPrintf(file,"W=%ld\n"   ,desc->DisplayWidth);
  2321.         FPrintf(file,"H=%ld\n"   ,desc->DisplayHeight);
  2322.         FPrintf(file,"D=%ld\n"   ,desc->DisplayDepth);
  2323.         FPrintf(file,"I=%ld\n"   ,desc->DisplayID   );
  2324.         if (desc->OverscanType) FPrintf(file,"OS\n");
  2325.         if (desc->AutoScroll  ) FPrintf(file,"AS\n");
  2326.         if (desc->NoDrag      ) FPrintf(file,"ND\n");
  2327.         if (desc->Exclusive   ) FPrintf(file,"EX\n");
  2328.         if (desc->Interleaved ) FPrintf(file,"IN\n");
  2329.         if (desc->SysDefault  ) FPrintf(file,"SD\n");
  2330.         if (desc->Behind      ) FPrintf(file,"BH\n");
  2331.         if (desc->AutoClose   ) FPrintf(file,"AC\n");
  2332.         if (desc->CloseGadget ) FPrintf(file,"CG\n");
  2333.  
  2334.         FPrintf(file,"PEN=\"");
  2335.         for (p=0;p<PSD_NUMSYSPENS;p++)
  2336.             FPrintf(file,"%ld:%ld ",p,desc->SystemPens[p]);
  2337.         FPrintf(file,"\"\n");
  2338.  
  2339.         FPrintf(file,"PAL=\"");
  2340.         for (p=0;p<PSD_NUMCOLS;p++)
  2341.             FPrintf(file,"%ld:%02lx%02lx%02lx ",p<4 ? p : p-8,desc->Palette[p].red>>24,desc->Palette[p].green>>24,desc->Palette[p].blue>>24);
  2342.         FPrintf(file,"\"\n");
  2343.  
  2344.         rc = TRUE;
  2345.  
  2346.         Close(file);
  2347.     }
  2348.     return(rc);
  2349. }
  2350.  
  2351.  
  2352. ULONG ScreenPanel_Foo(struct IClass *cl,Object *obj,Msg msg)
  2353. {
  2354.     struct ScreenPanel_Data *data = INST_DATA(cl,obj);
  2355.     struct MUI_PubScreenDesc *desc;
  2356.     int i;
  2357.  
  2358.     for (i=0;;i++)
  2359.     {
  2360.         int p;
  2361.  
  2362.         DoMethod(data->LV_Screens,MUIM_List_GetEntry,i,&desc);
  2363.         if (!desc) break;
  2364.  
  2365.         printf("N=\"%s\"\n",desc->Name        );
  2366.         printf("T=\"%s\"\n",desc->Title       );
  2367.         printf("F=\"%s\"\n",desc->Font        );
  2368.         printf("B=\"%s\"\n",desc->Background  );
  2369.         printf("W=%ld\n"   ,desc->DisplayWidth);
  2370.         printf("H=%ld\n"   ,desc->DisplayHeight);
  2371.         printf("D=%ld\n"   ,desc->DisplayDepth);
  2372.         printf("I=%ld\n"   ,desc->DisplayID   );
  2373.         if (desc->OverscanType) printf("OS\n");
  2374.         if (desc->AutoScroll  ) printf("AS\n");
  2375.         if (desc->NoDrag      ) printf("ND\n");
  2376.         if (desc->Exclusive   ) printf("EX\n");
  2377.         if (desc->Interleaved ) printf("IN\n");
  2378.         if (desc->SysDefault  ) printf("SD\n");
  2379.         if (desc->Behind      ) printf("BH\n");
  2380.         if (desc->AutoClose   ) printf("AC\n");
  2381.         if (desc->CloseGadget ) printf("CG\n");
  2382.  
  2383.         printf("PENS=\"");
  2384.         for (p=0;p<PSD_NUMSYSPENS;p++)
  2385.             printf("%ld:%ld ",p,desc->SystemPens[p]);
  2386.         printf("\"\n");
  2387.  
  2388.         printf("PALETTE=\"");
  2389.         for (p=0;p<PSD_NUMCOLS;p++)
  2390.             printf("%ld:%02lx%02lx%02lx ",p<4 ? p : p-8,desc->Palette[p].red>>24,desc->Palette[p].green>>24,desc->Palette[p].blue>>24);
  2391.         printf("\"\n");
  2392.  
  2393.         printf("\n");
  2394.  
  2395.         /*
  2396.         if (!desc->Foreign)
  2397.         */
  2398.             SavePubScreen(desc);
  2399.     }
  2400.     return(0);
  2401. }
  2402. #endif
  2403.  
  2404. SAVEDS ASM ULONG ScreenPanel_Dispatcher(REG(a0) struct IClass *cl,REG(a2) Object *obj,REG(a1) Msg msg)
  2405. {
  2406.     switch (msg->MethodID)
  2407.     {
  2408.         case OM_NEW                       : return(ScreenPanel_New         (cl,obj,(APTR)msg));
  2409.         case OM_DISPOSE                   : return(ScreenPanel_Dispose     (cl,obj,(APTR)msg));
  2410.         case MUIM_ScreenPanel_Create      : return(ScreenPanel_Create      (cl,obj,(APTR)msg));
  2411.         case MUIM_ScreenPanel_Copy        : return(ScreenPanel_Copy        (cl,obj,(APTR)msg));
  2412.         case MUIM_ScreenPanel_Delete      : return(ScreenPanel_Delete      (cl,obj,(APTR)msg));
  2413.         case MUIM_ScreenPanel_Edit        : return(ScreenPanel_Edit        (cl,obj,(APTR)msg));
  2414.         case MUIM_ScreenPanel_Finish      : return(ScreenPanel_Finish      (cl,obj,(APTR)msg));
  2415.         case MUIM_ScreenPanel_CloseWindows: return(ScreenPanel_CloseWindows(cl,obj,(APTR)msg));
  2416.         case MUIM_ScreenPanel_SetStates   : return(ScreenPanel_SetStates   (cl,obj,(APTR)msg));
  2417.         case MUIM_ScreenPanel_Open        : return(ScreenPanel_Open        (cl,obj,(APTR)msg));
  2418.         case MUIM_ScreenPanel_Close       : return(ScreenPanel_Close       (cl,obj,(APTR)msg));
  2419.         case MUIM_ScreenPanel_Jump        : return(ScreenPanel_Jump        (cl,obj,(APTR)msg));
  2420.         case MUIM_ScreenPanel_Update      : return(ScreenPanel_Update      (cl,obj,(APTR)msg));
  2421.         #ifdef MYDEBUG
  2422.         case MUIM_ScreenPanel_Foo         : return(ScreenPanel_Foo         (cl,obj,(APTR)msg));
  2423.         #endif
  2424.  
  2425.         case MUIM_ScreenList_Find:
  2426.         {
  2427.             struct ScreenPanel_Data *data = INST_DATA(cl,obj);
  2428.             return(DoMethodA(data->LV_Screens,msg));
  2429.         }
  2430.     }
  2431.     return(DoSuperMethodA(cl,obj,msg));
  2432. }
  2433.  
  2434.  
  2435.  
  2436. /****************************************************************************/
  2437. /* MainWindow class                                                         */
  2438. /****************************************************************************/
  2439.  
  2440. struct MainWindow_Data
  2441. {
  2442.     Object *PA_Screens;
  2443. };
  2444.  
  2445.  
  2446. ULONG MainWindow_Finish(struct IClass *cl,Object *obj,struct MUIP_MainWindow_Finish *msg)
  2447. {
  2448.     struct MainWindow_Data *data = INST_DATA(cl,obj);
  2449.     if (msg->level>=1) DoMethod(data->PA_Screens,MUIM_ScreenList_Save,PSD_FILENAME_USE );
  2450.     if (msg->level>=2) DoMethod(data->PA_Screens,MUIM_ScreenList_Save,PSD_FILENAME_SAVE);
  2451.     DoMethod((Object *)xget(obj,MUIA_ApplicationObject),MUIM_Application_ReturnID,MUIV_Application_ReturnID_Quit);
  2452.  
  2453.     return(0);
  2454. }
  2455.  
  2456. ULONG MainWindow_About(struct IClass *cl,Object *obj,Msg msg)
  2457. {
  2458.     struct MainWindow_Data *data = INST_DATA(cl,obj);
  2459.     Object *app = (Object *)xget(obj,MUIA_ApplicationObject);
  2460.     static const char AboutText[] = "\33b\33cPSI - Public Screen Inspector\33n\n\33cVersion: %s\n\33c%s\n\n\33c%s %ld\n\33cARexx-Port: %s";
  2461.     MUI_Request(app,obj,0,NULL,GetStr(MSG_BUTTON_OK),(char *)AboutText,
  2462.         ((char *)xget(app,MUIA_Application_Version))+10,
  2463.         ((char *)xget(app,MUIA_Application_Copyright)),
  2464.         GetStr(MSG_ABOUT_NUMBEROFSCREENS),
  2465.         xget(data->PA_Screens,MUIA_List_Entries),
  2466.         ((char *)xget(app,MUIA_Application_Base)));
  2467.     return(0);
  2468. }
  2469.  
  2470. SAVEDS ASM VOID IntuiMsgFunc(REG(a1) struct IntuiMessage *imsg,REG(a2) struct FileRequester *req)
  2471. {
  2472.     if (imsg->Class==IDCMP_REFRESHWINDOW)
  2473.         DoMethod(req->fr_UserData,MUIM_Application_CheckRefresh);
  2474. }
  2475.  
  2476. char *getfilename(Object *win,char *title,BOOL save)
  2477. {
  2478.     static char buf[512];
  2479.     struct FileRequester *req;
  2480.     struct Window *w;
  2481.     static LONG left=-1,top=-1,width=-1,height=-1;
  2482.     Object *app = (Object *)xget(win,MUIA_ApplicationObject);
  2483.     char *res = NULL;
  2484.     static const struct Hook IntuiMsgHook = { { 0,0 },(VOID *)IntuiMsgFunc,NULL,NULL };
  2485.  
  2486.     get(win,MUIA_Window_Window,&w);
  2487.     if (left==-1)
  2488.     {
  2489.         left   = w->LeftEdge+w->BorderLeft+2;
  2490.         top    = w->TopEdge+w->BorderTop+2;
  2491.         width  = w->Width-w->BorderLeft-w->BorderRight-4;
  2492.         height = w->Height-w->BorderTop-w->BorderBottom-4;
  2493.     }
  2494.  
  2495.     if (req=MUI_AllocAslRequestTags(ASL_FileRequest,
  2496.         ASLFR_Window, w,
  2497.         ASLFR_TitleText, title,
  2498.         ASLFR_InitialLeftEdge, left,
  2499.         ASLFR_InitialTopEdge , top,
  2500.         ASLFR_InitialWidth   , width,
  2501.         ASLFR_InitialHeight  , height,
  2502.         ASLFR_InitialDrawer  , "envarc:mui",
  2503.         ASLFR_InitialPattern , "#?.iff",
  2504.         ASLFR_DoSaveMode     , save,
  2505.         ASLFR_DoPatterns     , TRUE,
  2506.         ASLFR_RejectIcons    , TRUE,
  2507.         ASLFR_UserData       , app,
  2508.         ASLFR_IntuiMsgFunc   , &IntuiMsgHook,
  2509.         TAG_DONE))
  2510.     {
  2511.         set(app,MUIA_Application_Sleep,TRUE);
  2512.         if (MUI_AslRequestTags(req,TAG_DONE))
  2513.         {
  2514.             if (*req->fr_File)
  2515.             {
  2516.                 res = buf;
  2517.                 stccpy(buf,req->fr_Drawer,sizeof(buf));
  2518.                 AddPart(buf,req->fr_File,sizeof(buf));
  2519.             }
  2520.             left   = req->fr_LeftEdge;
  2521.             top    = req->fr_TopEdge;
  2522.             width  = req->fr_Width;
  2523.             height = req->fr_Height;
  2524.         }
  2525.         MUI_FreeAslRequest(req);
  2526.         set(app,MUIA_Application_Sleep,FALSE);
  2527.     }
  2528.     return(res);
  2529. }
  2530.  
  2531. ULONG MainWindow_Open(struct IClass *cl,Object *obj,struct MUIP_MainWindow_Open *msg)
  2532. {
  2533.     struct MainWindow_Data *data = INST_DATA(cl,obj);
  2534.     char *title = msg->append ? GetStr(MSG_TITLE_APPEND) : GetStr(MSG_TITLE_OPEN);
  2535.     char *name;
  2536.     if ((name=getfilename(obj,title,FALSE)) && *name)
  2537.     {
  2538.         if (!msg->append) DoMethod(data->PA_Screens,MUIM_ScreenPanel_CloseWindows);
  2539.         DoMethod(data->PA_Screens,MUIM_ScreenList_Load,name,msg->append ? FALSE : TRUE);
  2540.     }
  2541.     return(0);
  2542. }
  2543.  
  2544. ULONG MainWindow_SaveAs(struct IClass *cl,Object *obj,Msg msg)
  2545. {
  2546.     struct MainWindow_Data *data = INST_DATA(cl,obj);
  2547.     char *title = GetStr(MSG_TITLE_SAVE);
  2548.     char *name;
  2549.     if ((name=getfilename(obj,title,TRUE)) && *name)
  2550.     {
  2551.         DoMethod(data->PA_Screens,MUIM_ScreenList_Save,name);
  2552.     }
  2553.     return(0);
  2554. }
  2555.  
  2556. ULONG MainWindow_Restore(struct IClass *cl,Object *obj,struct MUIP_MainWindow_Restore *msg)
  2557. {
  2558.     struct MainWindow_Data *data = INST_DATA(cl,obj);
  2559.     DoMethod(data->PA_Screens,MUIM_ScreenPanel_CloseWindows);
  2560.     DoMethod(data->PA_Screens,MUIM_ScreenList_Load,msg->envarc ? PSD_FILENAME_SAVE : PSD_FILENAME_USE,TRUE);
  2561.     return(0);
  2562. }
  2563.  
  2564. ULONG MainWindow_New(struct IClass *cl,Object *obj,struct opSet *msg)
  2565. {
  2566.     Object *BT_Save;
  2567.     Object *BT_Use;
  2568.     Object *BT_Cancel;
  2569.     Object *PA_Screens;
  2570.     Object *strip;
  2571.  
  2572.     if (obj = (Object *)DoSuperNew(cl,obj,
  2573.             MUIA_Window_Title, "PSI - Public Screen Inspector",
  2574.             MUIA_Window_ID   , MAKE_ID('M','A','I','N'),
  2575.             MUIA_Window_Menustrip, strip = MUI_MakeObject(MUIO_MenustripNM,MainMenu,0),
  2576.             WindowContents, VGroup,
  2577.                 Child, PA_Screens = NewObject(CL_ScreenPanel->mcc_Class,NULL,TAG_DONE),
  2578.                 Child, MUI_MakeObject(MUIO_HBar,2),
  2579.                 Child, HGroup, MUIA_Group_SameSize, TRUE,
  2580.                     Child, BT_Save = MakeButton(MSG_BUTTON_SAVE),
  2581.                     Child, HSpace(0),
  2582.                     Child, BT_Use = MakeButton(MSG_BUTTON_USE),
  2583.                     Child, HSpace(0),
  2584.                     Child, BT_Cancel = MakeButton(MSG_BUTTON_CANCEL),
  2585.                     End,
  2586.                 End,
  2587.             TAG_MORE,msg->ops_AttrList))
  2588.     {
  2589.         struct MainWindow_Data *data = INST_DATA(cl,obj);
  2590.  
  2591.         data->PA_Screens = PA_Screens;
  2592.  
  2593.         DoMethod(obj      ,MUIM_Notify,MUIA_Window_CloseRequest,TRUE ,obj,2,MUIM_MainWindow_Finish,0);
  2594.         DoMethod(BT_Cancel,MUIM_Notify,MUIA_Pressed            ,FALSE,obj,2,MUIM_MainWindow_Finish,0);
  2595.         DoMethod(BT_Use   ,MUIM_Notify,MUIA_Pressed            ,FALSE,obj,2,MUIM_MainWindow_Finish,1);
  2596.         DoMethod(BT_Save  ,MUIM_Notify,MUIA_Pressed            ,FALSE,obj,2,MUIM_MainWindow_Finish,2);
  2597.  
  2598.         DoMethod((Object *)DoMethod(strip,MUIM_FindUData,MEN_ABOUT    ),MUIM_Notify,MUIA_Menuitem_Trigger,MUIV_EveryTime,obj,1,MUIM_MainWindow_About);
  2599.         DoMethod((Object *)DoMethod(strip,MUIM_FindUData,MEN_OPEN     ),MUIM_Notify,MUIA_Menuitem_Trigger,MUIV_EveryTime,obj,2,MUIM_MainWindow_Open,0);
  2600.         DoMethod((Object *)DoMethod(strip,MUIM_FindUData,MEN_APPEND   ),MUIM_Notify,MUIA_Menuitem_Trigger,MUIV_EveryTime,obj,2,MUIM_MainWindow_Open,1);
  2601.         DoMethod((Object *)DoMethod(strip,MUIM_FindUData,MEN_SAVEAS   ),MUIM_Notify,MUIA_Menuitem_Trigger,MUIV_EveryTime,obj,1,MUIM_MainWindow_SaveAs);
  2602.         DoMethod((Object *)DoMethod(strip,MUIM_FindUData,MEN_QUIT     ),MUIM_Notify,MUIA_Menuitem_Trigger,MUIV_EveryTime,obj,2,MUIM_MainWindow_Finish,0);
  2603.         DoMethod((Object *)DoMethod(strip,MUIM_FindUData,MEN_LASTSAVED),MUIM_Notify,MUIA_Menuitem_Trigger,MUIV_EveryTime,obj,2,MUIM_MainWindow_Restore,1);
  2604.         DoMethod((Object *)DoMethod(strip,MUIM_FindUData,MEN_RESTORE  ),MUIM_Notify,MUIA_Menuitem_Trigger,MUIV_EveryTime,obj,2,MUIM_MainWindow_Restore,0);
  2605.         DoMethod((Object *)DoMethod(strip,MUIM_FindUData,MEN_MUI      ),MUIM_Notify,MUIA_Menuitem_Trigger,MUIV_EveryTime,MUIV_Notify_Application,2,MUIM_Application_OpenConfigWindow,0);
  2606.  
  2607.         DoMethod(PA_Screens,MUIM_ScreenList_Load,PSD_FILENAME_USE,TRUE);
  2608.  
  2609.         set(BT_Save  ,MUIA_ShortHelp,GetStr(MSG_HELP_SAVE  ));
  2610.         set(BT_Use   ,MUIA_ShortHelp,GetStr(MSG_HELP_USE   ));
  2611.         set(BT_Cancel,MUIA_ShortHelp,GetStr(MSG_HELP_CANCEL));
  2612.  
  2613.         return((ULONG)obj);
  2614.     }
  2615.     return(0);
  2616. }
  2617.  
  2618. SAVEDS ASM ULONG MainWindow_Dispatcher(REG(a0) struct IClass *cl,REG(a2) Object *obj,REG(a1) Msg msg)
  2619. {
  2620.     switch (msg->MethodID)
  2621.     {
  2622.         case OM_NEW                 : return(MainWindow_New    (cl,obj,(APTR)msg));
  2623.         case MUIM_MainWindow_Finish : return(MainWindow_Finish (cl,obj,(APTR)msg));
  2624.         case MUIM_MainWindow_About  : return(MainWindow_About  (cl,obj,(APTR)msg));
  2625.         case MUIM_MainWindow_Open   : return(MainWindow_Open   (cl,obj,(APTR)msg));
  2626.         case MUIM_MainWindow_SaveAs : return(MainWindow_SaveAs (cl,obj,(APTR)msg));
  2627.         case MUIM_MainWindow_Restore: return(MainWindow_Restore(cl,obj,(APTR)msg));
  2628.  
  2629.         case MUIM_ScreenPanel_CloseWindows:
  2630.         case MUIM_ScreenPanel_Update:
  2631.         case MUIM_ScreenList_Find:
  2632.         {
  2633.             struct MainWindow_Data *data = INST_DATA(cl,obj);
  2634.             return(DoMethodA(data->PA_Screens,msg));
  2635.         }
  2636.     }
  2637.     return(DoSuperMethodA(cl,obj,msg));
  2638. }
  2639.  
  2640.  
  2641.  
  2642. /****************************************************************************/
  2643. /* Init/Exit Functions                                                      */
  2644. /****************************************************************************/
  2645.  
  2646. VOID ExitLibs(VOID)
  2647. {
  2648.     if (IntuitionBase) CloseLibrary(IntuitionBase);
  2649.     if (GfxBase      ) CloseLibrary(GfxBase      );
  2650.     if (AslBase      ) CloseLibrary(AslBase      );
  2651.     if (UtilityBase  ) CloseLibrary(UtilityBase  );
  2652.     if (MUIScreenBase) CloseLibrary(MUIScreenBase);
  2653.     if (MUIMasterBase) CloseLibrary(MUIMasterBase);
  2654. }
  2655.  
  2656. BOOL InitLibs(VOID)
  2657. {
  2658.     MUIMasterBase = OpenLibrary("muimaster.library",11);
  2659.     MUIScreenBase = OpenLibrary("muiscreen.library",11);
  2660.     UtilityBase   = OpenLibrary("utility.library"  ,36);
  2661.     AslBase       = OpenLibrary("asl.library"      ,36);
  2662.     GfxBase       = OpenLibrary("graphics.library" ,36);
  2663.     IntuitionBase = OpenLibrary("intuition.library",36);
  2664.  
  2665.     if (MUIMasterBase && MUIScreenBase && UtilityBase && AslBase && GfxBase && IntuitionBase)
  2666.         return(TRUE);
  2667.  
  2668.     ExitLibs();
  2669.     return(FALSE);
  2670. }
  2671.  
  2672. VOID ExitClasses(VOID)
  2673. {
  2674.     if (CL_MainWindow  ) MUI_DeleteCustomClass(CL_MainWindow  );
  2675.     if (CL_ScreenPanel ) MUI_DeleteCustomClass(CL_ScreenPanel );
  2676.     if (CL_ScreenList  ) MUI_DeleteCustomClass(CL_ScreenList  );
  2677.     if (CL_DispIDinfo  ) MUI_DeleteCustomClass(CL_DispIDinfo  );
  2678.     if (CL_DispIDlist  ) MUI_DeleteCustomClass(CL_DispIDlist  );
  2679.     if (CL_EditPanel   ) MUI_DeleteCustomClass(CL_EditPanel   );
  2680.     if (CL_EditWindow  ) MUI_DeleteCustomClass(CL_EditWindow  );
  2681.     if (CL_SysPenField ) MUI_DeleteCustomClass(CL_SysPenField );
  2682. }
  2683.  
  2684. BOOL InitClasses(VOID)
  2685. {
  2686.     CL_SysPenField  = MUI_CreateCustomClass(NULL,MUIC_Pendisplay,NULL,sizeof(struct SysPenField_Data ),SysPenField_Dispatcher );
  2687.     CL_EditWindow   = MUI_CreateCustomClass(NULL,MUIC_Window    ,NULL,sizeof(struct EditWindow_Data  ),EditWindow_Dispatcher  );
  2688.     CL_EditPanel    = MUI_CreateCustomClass(NULL,MUIC_Group     ,NULL,sizeof(struct EditPanel_Data   ),EditPanel_Dispatcher   );
  2689.     CL_DispIDlist   = MUI_CreateCustomClass(NULL,MUIC_List      ,NULL,sizeof(struct DispIDlist_Data  ),DispIDlist_Dispatcher  );
  2690.     CL_DispIDinfo   = MUI_CreateCustomClass(NULL,MUIC_Group     ,NULL,sizeof(struct DispIDinfo_Data  ),DispIDinfo_Dispatcher  );
  2691.     CL_ScreenList   = MUI_CreateCustomClass(NULL,MUIC_List      ,NULL,sizeof(struct ScreenList_Data  ),ScreenList_Dispatcher  );
  2692.     CL_ScreenPanel  = MUI_CreateCustomClass(NULL,MUIC_Group     ,NULL,sizeof(struct ScreenPanel_Data ),ScreenPanel_Dispatcher );
  2693.     CL_MainWindow   = MUI_CreateCustomClass(NULL,MUIC_Window    ,NULL,sizeof(struct MainWindow_Data  ),MainWindow_Dispatcher  );
  2694.  
  2695.     if (CL_SysPenField && CL_EditWindow && CL_EditPanel && CL_DispIDlist && CL_DispIDinfo && CL_ScreenList && CL_ScreenPanel && CL_MainWindow)
  2696.         return(TRUE);
  2697.  
  2698.     ExitClasses();
  2699.     return(FALSE);
  2700. }
  2701.  
  2702.  
  2703. const char CLITemplate[] = "NAME,OPEN/S,CLOSE/S";
  2704.  
  2705. const char CLIHelp[] = "\
  2706. \n\
  2707. Usage: PSI <name> OPEN/CLOSE\n\
  2708. <name>: name of (preconfigured) public screen\n\
  2709.  OPEN : open this public screen\n\
  2710.  CLOSE: close this public screen\n\
  2711. ";
  2712.  
  2713. LONG HandleArgs(Object *mainwin)
  2714. {
  2715.     struct MUI_PubScreenDesc *desc;
  2716.     struct RDArgs *rda,*rdas;
  2717.     LONG msg = 0;
  2718.     struct CLIArgs
  2719.     {
  2720.         char *Name;
  2721.         LONG Open;
  2722.         LONG Close;
  2723.     } argarray = { 0,0,0 };
  2724.  
  2725.     if (rdas = AllocDosObject(DOS_RDARGS,NULL))
  2726.     {
  2727.         rdas->RDA_ExtHelp = (char *)CLIHelp;
  2728.  
  2729.         if (rda = ReadArgs((char *)CLITemplate,(LONG *)&argarray,rdas))
  2730.         {
  2731.             if (argarray.Name)
  2732.             {
  2733.                 DoMethod(mainwin,MUIM_ScreenList_Find,argarray.Name,&desc);
  2734.  
  2735.                 if (argarray.Open)
  2736.                 {
  2737.                     if (!desc)
  2738.                         msg = MSG_CLI_SCREENNOTFOUND;
  2739.                     else if (MUIS_OpenPubScreen(desc))
  2740.                         msg = MSG_CLI_SCREENOPENED;
  2741.                     else
  2742.                         msg = MSG_CLI_SCREENOPENFAILED;
  2743.                 }
  2744.                 else if (argarray.Close)
  2745.                 {
  2746.                     if (!desc)
  2747.                         msg = MSG_CLI_SCREENNOTFOUND;
  2748.                     else if (MUIS_ClosePubScreen(desc->Name))
  2749.                         msg = MSG_CLI_SCREENCLOSED;
  2750.                     else
  2751.                         msg = MSG_CLI_SCREENCLOSEFAILED;
  2752.                 }
  2753.             }
  2754.             else
  2755.             {
  2756.                 if (argarray.Open || argarray.Close)
  2757.                     msg = MSG_CLI_SYNTAXERROR;
  2758.             }
  2759.             FreeArgs(rda);
  2760.         }
  2761.         FreeDosObject(DOS_RDARGS,rdas);
  2762.     }
  2763.     else
  2764.         msg = MSG_CLI_OUTOFMEMORY;
  2765.  
  2766.     return(msg);
  2767. }
  2768.  
  2769.  
  2770.  
  2771. /****************************************************************************/
  2772. /* Main Program                                                             */
  2773. /****************************************************************************/
  2774.  
  2775. /*int main(int argc,char *argv[])*/
  2776. void __stdargs __main(char *comline)
  2777. {
  2778.     extern struct WBStartup *_WBenchMsg;
  2779.     struct MUIS_InfoClient sic;
  2780.     ULONG sigs=0;
  2781.     Object *app;
  2782.     Object *win;
  2783.     int res;
  2784.     int msg;
  2785.  
  2786.     InitLocale();
  2787.  
  2788.     if (InitLibs())
  2789.     {
  2790.         if (InitClasses())
  2791.         {
  2792.             app = ApplicationObject,
  2793.                 MUIA_Application_Title      , "PSI",
  2794.                 MUIA_Application_Version    , VersionString,
  2795.                 MUIA_Application_Copyright  , "©1995-97, Stefan Stuntz",
  2796.                 MUIA_Application_Author     , "Stefan Stuntz",
  2797.                 MUIA_Application_Description, "Public Screen Inspector",
  2798.                 MUIA_Application_Base       , "PSI",
  2799.                 MUIA_Application_Window     , win = NewObject(CL_MainWindow->mcc_Class,NULL,TAG_DONE),
  2800.                 End;
  2801.  
  2802.             if (app)
  2803.             {
  2804.                 if (/*argc==0*/ _WBenchMsg)
  2805.                     msg = 0;
  2806.                 else
  2807.                     msg = HandleArgs(win);
  2808.  
  2809.                 if (!msg)
  2810.                 {
  2811.                     set(win,MUIA_Window_Open,TRUE);
  2812.  
  2813.                     /* special magic to keep track about public screen open/close status */
  2814.                     sic.task   = FindTask(NULL);
  2815.                     sic.sigbit = SIGBREAKF_CTRL_E;
  2816.                     MUIS_AddInfoClient(&sic);
  2817.  
  2818.                     while (DoMethod(app,MUIM_Application_NewInput,&sigs) != MUIV_Application_ReturnID_Quit)
  2819.                     {
  2820.                         if (sigs)
  2821.                         {
  2822.                             sigs = Wait(sigs | SIGBREAKF_CTRL_C | SIGBREAKF_CTRL_E | SIGBREAKF_CTRL_F);
  2823.  
  2824.                             /* quit when receiving break from console */
  2825.                             if (sigs & SIGBREAKF_CTRL_C)
  2826.                                 break;
  2827.  
  2828.                             /* update listview whenever a screen was opened/closed */
  2829.                             if (sigs & SIGBREAKF_CTRL_E)
  2830.                                 DoMethod(win,MUIM_ScreenPanel_Update);
  2831.  
  2832.                             /* deiconify & activate on ctrl-f just like the other prefs programs */
  2833.                             if (sigs & SIGBREAKF_CTRL_F)
  2834.                             {
  2835.                                 set(app,MUIA_Application_Iconified,FALSE);
  2836.                                 set(win,MUIA_Window_Open,TRUE);
  2837.                             }
  2838.                         }
  2839.                     }
  2840.  
  2841.                     MUIS_RemInfoClient(&sic);
  2842.  
  2843.                     DoMethod(win,MUIM_ScreenPanel_CloseWindows);
  2844.                     set(win,MUIA_Window_Open,FALSE);
  2845.                 }
  2846.                 MUI_DisposeObject(app);
  2847.             }
  2848.             else msg = MSG_CLI_NOAPPLICATION;
  2849.             ExitClasses();
  2850.         }
  2851.         else msg = MSG_CLI_OUTOFMEMORY;
  2852.         ExitLibs();
  2853.     }
  2854.     else msg = MSG_CLI_NOMUIMASTER;
  2855.  
  2856.     if (msg)
  2857.     {
  2858.         char *str = GetStr(msg);
  2859.         char *c = strchr(str,'(');
  2860.         Write(Output(),str,strlen(str));
  2861.         res = c ? atol(c+1) : RETURN_OK;
  2862.     }
  2863.     else
  2864.         res = RETURN_OK;
  2865.  
  2866.     ExitLocale();
  2867.     /*return(res);*/
  2868.     exit(res);
  2869. }
  2870.